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

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.53 by root, Tue May 22 10:50:01 2007 UTC vs.
Revision 1.148 by root, Sat Nov 17 23:40:04 2018 UTC

1/* 1/*
2 * CrossFire, A Multiplayer game 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team 4 * Copyright (©) 2017,2018 Marc Alexander Lehmann / 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 (C) 2002 Mark Wedel & Crossfire Development Team 6 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6 * Copyright (C) 1992 Frank Tore Johansen 7 * Copyright (©) 1992 Frank Tore Johansen
7 * 8 *
8 * This program is free software; you can redistribute it and/or modify 9 * Deliantra is free software: you can redistribute it and/or modify it under
9 * it under the terms of the GNU General Public License as published by 10 * the terms of the Affero GNU General Public License as published by the
10 * the Free Software Foundation; either version 2 of the License, or 11 * Free Software Foundation, either version 3 of the License, or (at your
11 * (at your 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 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 * 18 *
19 * You should have received a copy of the Affero GNU General Public License
20 * and the GNU General Public License along with this program. If not, see
21 * <http://www.gnu.org/licenses/>.
22 *
22 * The authors can be reached via e-mail at <crossfire@schmorp.de> 23 * The authors can be reached via e-mail to <support@deliantra.net>
23 */ 24 */
24 25
25#include <global.h> 26#include <global.h>
26#include <object.h> 27#include <object.h>
27#include <living.h> 28#include <living.h>
… …
58} 59}
59 60
60int 61int
61recharge (object *op, object *caster, object *spell_ob) 62recharge (object *op, object *caster, object *spell_ob)
62{ 63{
63 object *wand, *tmp;
64 int ncharges; 64 int ncharges;
65 65
66 wand = find_marked_object (op); 66 object *wand = op->mark ();
67
67 if (wand == NULL || wand->type != WAND) 68 if (!wand || wand->type != WAND)
68 { 69 {
69 new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge."); 70 op->failmsg ("You need to mark the wand you want to recharge.");
70 return 0; 71 return 0;
71 } 72 }
73
72 if (!(random_roll (0, 3, op, PREFER_HIGH))) 74 if (!(random_roll (0, 3, op, PREFER_HIGH)))
73 { 75 {
74 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand)); 76 op->failmsgf ("The %s vibrates violently, then explodes!", query_name (wand));
75 play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE); 77 op->play_sound (sound_find ("ob_explode"));
76 esrv_del_item (op->contr, wand->count);
77 wand->destroy (); 78 wand->destroy ();
78 tmp = get_archetype ("fireball"); 79 object *tmp = archetype::get (shstr_fireball);
79 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10; 80 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
80 81
81 if (!tmp->stats.dam) 82 if (!tmp->stats.dam)
82 tmp->stats.dam = 1; 83 tmp->stats.dam = 1;
83 84
… …
94 95
95 if (wand->inv && wand->inv->level) 96 if (wand->inv && wand->inv->level)
96 ncharges /= wand->inv->level; 97 ncharges /= wand->inv->level;
97 else 98 else
98 { 99 {
99 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand)); 100 op->failmsgf ("Your %s is broken.", query_name (wand));
100 return 0; 101 return 0;
101 } 102 }
102 103
103 if (!ncharges) 104 if (!ncharges)
104 ncharges = 1; 105 ncharges = 1;
105 106
106 wand->stats.food += ncharges; 107 wand->stats.food += ncharges;
107 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand)); 108 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));
108 109
109 if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE)) 110 if (wand->arch && wand->arch->flag [FLAG_ANIMATE])
110 { 111 {
111 SET_FLAG (wand, FLAG_ANIMATE); 112 wand->set_flag (FLAG_ANIMATE);
112 wand->set_speed (wand->arch->clone.speed); 113 wand->set_speed (wand->arch->speed);
113 } 114 }
114 115
115 return 1; 116 return 1;
116} 117}
117 118
… …
123 * great a plus, the default is used. 124 * great a plus, the default is used.
124 * The # of arrows created also goes up with level, so if a 30th level mage 125 * The # of arrows created also goes up with level, so if a 30th level mage
125 * wants LOTS of arrows, and doesn't care what the plus is he could 126 * wants LOTS of arrows, and doesn't care what the plus is he could
126 * create nonnmagic arrows, or even -1, etc... 127 * create nonnmagic arrows, or even -1, etc...
127 */ 128 */
128
129int 129int
130cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg) 130cast_create_missile (object *op, object *caster, object *spell, int dir, const char *spellparam)
131{ 131{
132 int missile_plus = 0, bonus_plus = 0; 132 int bonus_plus = 0;
133 const char *missile_name; 133 const char *missile_name = "arrow";
134 object *tmp, *missile;
135 134
136 missile_name = "arrow";
137
138 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 135 for (object *tmp = op->inv; tmp; tmp = tmp->below)
139 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED)) 136 if (tmp->type == BOW && tmp->flag [FLAG_APPLIED])
140 missile_name = tmp->race; 137 missile_name = tmp->race;
141 138
142 missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell); 139 int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
143 140
144 if (archetype::find (missile_name) == NULL) 141 archetype *missile_arch = archetype::find (missile_name);
142
143 if (!missile_arch)
145 { 144 {
146 LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name); 145 LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);
147 return 0; 146 return 0;
148 } 147 }
149 148
150 missile = get_archetype (missile_name); 149 object *missile = missile_arch->instance ();
151 150
152 if (stringarg) 151 if (spellparam)
153 { 152 {
154 /* If it starts with a letter, presume it is a description */ 153 /* If it starts with a letter, presume it is a description */
155 if (isalpha (*stringarg)) 154 if (isalpha (*spellparam))
156 { 155 {
157 artifact *al = find_artifactlist (missile->type)->items; 156 artifact *al = find_artifactlist (missile->type)->items;
158 157
159 for (; al; al = al->next) 158 for (; al; al = al->next)
160 if (!strcasecmp (al->item->name, stringarg)) 159 if (!strcasecmp (al->item->name, spellparam))
161 break; 160 break;
162 161
163 if (!al) 162 if (!al)
164 { 163 {
165 missile->destroy (); 164 missile->destroy ();
166 new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, stringarg); 165 op->failmsgf ("No such object %ss of %s", missile_name, spellparam);
167 return 0; 166 return 0;
168 } 167 }
169 168
170 if (al->item->slaying) 169 if (al->item->slaying)
171 { 170 {
172 missile->destroy (); 171 missile->destroy ();
173 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg); 172 op->failmsgf ("You are not allowed to create %ss of %s", missile_name, spellparam);
174 return 0; 173 return 0;
175 } 174 }
176 175
177 give_artifact_abilities (missile, al->item); 176 give_artifact_abilities (missile, al->item);
178 /* These special arrows cost something extra. Don't have them also be magical - 177 /* These special arrows cost something extra. Don't have them also be magical -
179 * otherwise, in most cases, not enough will be created. I don't want to get into 178 * otherwise, in most cases, not enough will be created. I don't want to get into
180 * the parsing of having to do both plus and type. 179 * the parsing of having to do both plus and type.
181 */ 180 */
182 bonus_plus = 1 + (al->item->value / 5); 181 bonus_plus = 1 + (al->item->value / 5);
183 missile_plus = 0; 182 missile_plus = 0;
184 } 183 }
185 else if (atoi (stringarg) < missile_plus) 184 else if (atoi (spellparam) < missile_plus)
186 missile_plus = atoi (stringarg); 185 missile_plus = atoi (spellparam);
187 } 186 }
188 187
189 if (missile_plus > 4) 188 missile_plus = clamp (missile_plus, -4, 4);
190 missile_plus = 4;
191 else if (missile_plus < -4)
192 missile_plus = -4;
193 189
194 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell); 190 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
195 missile->nrof -= 3 * (missile_plus + bonus_plus); 191 missile->nrof -= 3 * (missile_plus + bonus_plus);
196 192
197 if (missile->nrof < 1) 193 if (missile->nrof < 1)
… …
199 195
200 missile->magic = missile_plus; 196 missile->magic = missile_plus;
201 /* Can't get any money for these objects */ 197 /* Can't get any money for these objects */
202 missile->value = 0; 198 missile->value = 0;
203 199
204 SET_FLAG (missile, FLAG_IDENTIFIED); 200 missile->set_flag (FLAG_IDENTIFIED);
205 201
206 if (!cast_create_obj (op, caster, missile, dir) && op->type == PLAYER && !missile->destroyed ()) 202 cast_create_obj (op, caster, missile, dir);
203
204 if (!dir
205 && op->type == PLAYER
206 && !missile->destroyed ())
207 pick_up (op, missile); 207 pick_up (op, missile);
208 208
209 return 1; 209 return 1;
210} 210}
211 211
212
213/* allows the choice of what sort of food object to make. 212/* allows the choice of what sort of food object to make.
214 * If stringarg is NULL, it will create food dependent on level --PeterM*/ 213 * If spellparam is NULL, it will create food dependent on level --PeterM*/
215int 214int
216cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *stringarg) 215cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *spellparam)
217{ 216{
218 int food_value; 217 int food_value;
219 archetype *at = NULL; 218 archetype *at = NULL;
220 object *new_op; 219 object *new_op;
221 220
222 food_value = spell_ob->stats.food + +50 * SP_level_duration_adjust (caster, spell_ob); 221 food_value = spell_ob->stats.food + 50 * SP_level_duration_adjust (caster, spell_ob);
223 222
224 if (stringarg) 223 if (spellparam)
225 { 224 {
226 at = find_archetype_by_object_type_name (FOOD, stringarg); 225 at = find_archetype_by_object_type_name (FOOD, spellparam);
227 if (at == NULL) 226 if (at == NULL)
228 at = find_archetype_by_object_type_name (DRINK, stringarg); 227 at = find_archetype_by_object_type_name (DRINK, spellparam);
229 if (at == NULL || at->clone.stats.food > food_value) 228 if (at == NULL || at->stats.food > food_value)
230 stringarg = NULL; 229 spellparam = NULL;
231 } 230 }
232 231
233 if (!stringarg) 232 if (!spellparam)
234 { 233 {
235 archetype *at_tmp; 234 archetype *at_tmp;
236 235
237 /* We try to find the archetype with the maximum food value. 236 /* We try to find the archetype with the maximum food value.
238 * This removes the dependancy of hard coded food values in this 237 * This removes the dependancy of hard coded food values in this
… …
240 * We don't use flesh types because the weight values of those need 239 * We don't use flesh types because the weight values of those need
241 * to be altered from the donor. 240 * to be altered from the donor.
242 */ 241 */
243 242
244 /* We assume the food items don't have multiple parts */ 243 /* We assume the food items don't have multiple parts */
245 for (at_tmp = first_archetype; at_tmp != NULL; at_tmp = at_tmp->next) 244 for_all_archetypes (at_tmp)
246 { 245 {
247 if (at_tmp->clone.type == FOOD || at_tmp->clone.type == DRINK) 246 if (at_tmp->type == FOOD || at_tmp->type == DRINK)
248 { 247 {
249 /* Basically, if the food value is something that is creatable 248 /* Basically, if the food value is something that is creatable
250 * under the limits of the spell and it is higher than 249 * under the limits of the spell and it is higher than
251 * the item we have now, take it instead. 250 * the item we have now, take it instead.
252 */ 251 */
253 if (at_tmp->clone.stats.food <= food_value && (!at || at_tmp->clone.stats.food > at->clone.stats.food)) 252 if (at_tmp->stats.food <= food_value
253 && (!at
254 || at_tmp->stats.food > at->stats.food
255 || (at_tmp->stats.food == at->stats.food
256 && at_tmp->weight < at->weight)))
254 at = at_tmp; 257 at = at_tmp;
255 } 258 }
256 } 259 }
257 } 260 }
261
258 /* Pretty unlikely (there are some very low food items), but you never 262 /* Pretty unlikely (there are some very low food items), but you never
259 * know 263 * know
260 */ 264 */
261 if (!at) 265 if (!at)
262 { 266 {
263 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food."); 267 op->failmsgf ("You don't have enough experience to create any food.");
264 return 0; 268 return 0;
265 } 269 }
266 270
267 food_value /= at->clone.stats.food; 271 food_value /= at->stats.food;
268 new_op = arch_to_object (at); 272 new_op = at->instance ();
269 new_op->nrof = food_value; 273 new_op->nrof = food_value;
270 274
271 new_op->value = 0; 275 new_op->value = 0;
272 if (new_op->nrof < 1) 276 if (new_op->nrof < 1)
273 new_op->nrof = 1; 277 new_op->nrof = 1;
… …
281{ 285{
282 int r, mflags, maxrange; 286 int r, mflags, maxrange;
283 object *tmp; 287 object *tmp;
284 maptile *m; 288 maptile *m;
285 289
286
287 if (!dir) 290 if (!dir)
288 { 291 {
289 examine_monster (op, op); 292 examine_monster (op, op);
290 return 1; 293 return 1;
291 } 294 }
295
292 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 296 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
293 for (r = 1; r < maxrange; r++) 297 for (r = 1; r < maxrange; r++)
294 { 298 {
295 sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir]; 299 sint16 x = op->x + r * DIRX (dir), y = op->y + r * DIRY (dir);
296 300
297 m = op->map; 301 m = op->map;
298 mflags = get_map_flags (m, &m, x, y, &x, &y); 302 mflags = get_map_flags (m, &m, x, y, &x, &y);
299 303
300 if (mflags & P_OUT_OF_MAP) 304 if (mflags & P_OUT_OF_MAP)
301 break; 305 break;
302 306
303 if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC)) 307 if (!op->flag [FLAG_WIZCAST] && (mflags & P_NO_MAGIC))
304 { 308 {
305 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic."); 309 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");
306 return 0; 310 return 0;
307 } 311 }
312
308 if (mflags & P_IS_ALIVE) 313 if (mflags & P_IS_ALIVE)
309 { 314 {
310 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above) 315 for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
311 if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER))) 316 if (tmp->flag [FLAG_ALIVE] && (tmp->type == PLAYER || tmp->flag [FLAG_MONSTER]))
312 { 317 {
313 new_draw_info (NDI_UNIQUE, 0, op, "You detect something."); 318 new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");
314 if (tmp->head != NULL) 319 if (tmp->head != NULL)
315 tmp = tmp->head; 320 tmp = tmp->head;
316 examine_monster (op, tmp); 321 examine_monster (op, tmp);
317 return 1; 322 return 1;
318 } 323 }
319 } 324 }
320 } 325 }
326
321 new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing."); 327 new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");
322 return 1; 328 return 1;
323} 329}
324
325 330
326/* This checks to see if 'pl' is invisible to 'mon'. 331/* This checks to see if 'pl' is invisible to 'mon'.
327 * does race check, undead check, etc 332 * does race check, undead check, etc
328 * Returns TRUE if mon can't see pl, false 333 * Returns TRUE if mon can't see pl, false
329 * otherwise. This doesn't check range, walls, etc. It 334 * otherwise. This doesn't check range, walls, etc. It
… …
331 * pl is invisible. 336 * pl is invisible.
332 */ 337 */
333int 338int
334makes_invisible_to (object *pl, object *mon) 339makes_invisible_to (object *pl, object *mon)
335{ 340{
336
337 if (!pl->invisible) 341 if (!pl->invisible)
338 return 0; 342 return 0;
343
339 if (pl->type == PLAYER) 344 if (pl->type == PLAYER)
340 { 345 {
341 /* If race isn't set, then invisible unless it is undead */ 346 /* If race isn't set, then invisible unless it is undead */
342 if (!pl->contr->invis_race) 347 if (!pl->contr->invis_race)
343 { 348 {
344 if (QUERY_FLAG (mon, FLAG_UNDEAD)) 349 if (mon->flag [FLAG_UNDEAD])
345 return 0; 350 return 0;
351
346 return 1; 352 return 1;
347 } 353 }
354
348 /* invis_race is set if we get here */ 355 /* invis_race is set if we get here */
349 if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon)) 356 if (pl->contr->invis_race == shstr_undead && is_true_undead (mon))
350 return 1; 357 return 1;
358
351 /* No race, can't be invisible to it */ 359 /* No race, can't be invisible to it */
352 if (!mon->race) 360 if (!mon->race)
353 return 0; 361 return 0;
362
354 if (strstr (mon->race, pl->contr->invis_race)) 363 if (mon->race.contains (pl->contr->invis_race))
355 return 1; 364 return 1;
365
356 /* Nothing matched above, return 0 */ 366 /* Nothing matched above, return 0 */
357 return 0; 367 return 0;
358 } 368 }
359 else 369 else
360 { 370 {
… …
375int 385int
376cast_invisible (object *op, object *caster, object *spell_ob) 386cast_invisible (object *op, object *caster, object *spell_ob)
377{ 387{
378 if (op->invisible > 1000) 388 if (op->invisible > 1000)
379 { 389 {
380 new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further"); 390 op->failmsg ("You can not extend the duration of your invisibility any further");
381 return 0; 391 return 0;
382 } 392 }
383 393
384 /* Remove the switch with 90% duplicate code - just handle the differences with 394 /* Remove the switch with 90% duplicate code - just handle the differences with
385 * and if statement or two. 395 * and if statement or two.
386 */ 396 */
387 op->invisible += spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 397 op->invisible += spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
398
388 /* max duration */ 399 /* limit duration */
389 if (op->invisible > 1000) 400 min_it (op->invisible, 1000);
390 op->invisible = 1000;
391 401
392 if (op->type == PLAYER) 402 if (op->type == PLAYER)
393 { 403 {
394 op->contr->invis_race = spell_ob->race; 404 op->contr->invis_race = spell_ob->race;
395 405
396 if (QUERY_FLAG (spell_ob, FLAG_MAKE_INVIS)) 406 if (spell_ob->flag [FLAG_MAKE_INVIS])
397 op->contr->tmp_invis = 0; 407 op->contr->tmp_invis = 0;
398 else 408 else
399 op->contr->tmp_invis = 1; 409 op->contr->tmp_invis = 1;
400
401 op->contr->hidden = 0;
402 } 410 }
403 411
404 if (makes_invisible_to (op, op)) 412 if (makes_invisible_to (op, op))
405 new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!"); 413 new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");
406 else 414 else
… …
421/* earth to dust spell. Basically destroys earthwalls in the area. 429/* earth to dust spell. Basically destroys earthwalls in the area.
422 */ 430 */
423int 431int
424cast_earth_to_dust (object *op, object *caster, object *spell_ob) 432cast_earth_to_dust (object *op, object *caster, object *spell_ob)
425{ 433{
426 object *tmp, *next;
427 int range, i, j, mflags; 434 int range, i, j, mflags;
428 sint16 sx, sy; 435 sint16 sx, sy;
429 maptile *m; 436 maptile *m;
430
431 if (op->type != PLAYER)
432 return 0;
433 437
434 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 438 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
435 439
436 for (i = -range; i <= range; i++) 440 for (i = -range; i <= range; i++)
437 for (j = -range; j <= range; j++) 441 for (j = -range; j <= range; j++)
… …
442 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy); 446 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
443 447
444 if (mflags & P_OUT_OF_MAP) 448 if (mflags & P_OUT_OF_MAP)
445 continue; 449 continue;
446 450
447 // earth to dust tears down everything that can be teared down 451 // earth to dust tears down everything that can be torn down
448 for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next) 452 for (object *next, *tmp = m->at (sx, sy).bot; tmp; tmp = next)
449 { 453 {
450 next = tmp->above; 454 next = tmp->above;
451 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN)) 455
456 if (tmp->flag [FLAG_TEAR_DOWN])
452 hit_player (tmp, 9998, op, AT_PHYSICAL, 0); 457 hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
453 } 458 }
454 } 459 }
455 460
456 return 1; 461 return 1;
… …
458 463
459void 464void
460execute_word_of_recall (object *op) 465execute_word_of_recall (object *op)
461{ 466{
462 if (object *pl = op->in_player ()) 467 if (object *pl = op->in_player ())
463 {
464 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST)) 468 if (pl->ms ().flags () & P_NO_CLERIC && !pl->flag [FLAG_WIZCAST])
465 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you."); 469 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
466 else 470 else
467 { 471 pl->player_goto (op->slaying, op->stats.hp, op->stats.sp);
468 // remove first so we do not call update_stats
469 op->remove ();
470 pl->enter_exit (op);
471 }
472 }
473 472
474 op->destroy (); 473 op->destroy ();
475} 474}
476 475
477/* Word of recall causes the player to return 'home'. 476/* Word of recall causes the player to return 'home'.
478 * we put a force into the player object, so that there is a 477 * we put a force into the player object, so that there is a
479 * time delay effect. 478 * time delay effect.
480 */ 479 */
481int 480int
482cast_word_of_recall (object *op, object *caster, object *spell_ob) 481cast_word_of_recall (object *op, object *caster, object *spell_ob)
483{ 482{
484 object *dummy; 483 if (!op->is_player ())
485 int time;
486
487 if (op->type != PLAYER)
488 return 0; 484 return 0;
489 485
490 if (find_obj_by_type_subtype (op, SPELL_EFFECT, SP_WORD_OF_RECALL)) 486 if (find_obj_by_type_subtype (op, SPELL_EFFECT, SP_WORD_OF_RECALL))
491 { 487 {
492 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you."); 488 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
493 return 1; 489 return 1;
494 } 490 }
495 491
496 dummy = get_archetype (FORCE_NAME); 492 object *dummy = archetype::get (FORCE_NAME);
497 if (dummy == NULL)
498 {
499 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
500 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
501 return 0;
502 }
503 493
504 time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob); 494 int time = max (1, spell_ob->duration - SP_level_duration_adjust (caster, spell_ob));
505 if (time < 1)
506 time = 1;
507 495
508 /* value of speed really doesn't make much difference, as long as it is 496 /* value of speed really doesn't make much difference, as long as it is
509 * positive. Lower value may be useful so that the problem doesn't 497 * positive. Lower value may be useful so that the problem doesn't
510 * do anything really odd if it say a -1000 or something. 498 * do anything really odd if it say a -1000 or something.
511 */ 499 */
512 dummy->set_speed (0.002); 500 dummy->set_speed (0.002);
513 dummy->speed_left = -dummy->speed * time; 501 dummy->speed_left = -dummy->speed * time;
514 dummy->type = SPELL_EFFECT; 502 dummy->type = SPELL_EFFECT;
515 dummy->subtype = SP_WORD_OF_RECALL; 503 dummy->subtype = SP_WORD_OF_RECALL;
516 504 dummy->slaying = op->contr->savebed_map;
517 /* If we could take advantage of enter_player_savebed() here, it would be 505 dummy->stats.hp = op->contr->bed_x;
518 * nice, but until the map load fails, we can't. 506 dummy->stats.sp = op->contr->bed_y;
519 */
520 EXIT_PATH (dummy) = op->contr->savebed_map;
521 EXIT_X (dummy) = op->contr->bed_x;
522 EXIT_Y (dummy) = op->contr->bed_y;
523 507
524 op->insert (dummy); 508 op->insert (dummy);
525 509
526 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you."); 510 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
527 511
… …
565} 549}
566 550
567int 551int
568perceive_self (object *op) 552perceive_self (object *op)
569{ 553{
570 char buf[MAX_BUF];
571 const char *cp = describe_item (op, op); 554 const char *cp = describe_item (op, op);
572 archetype *at = archetype::find (ARCH_DEPLETION); 555 archetype *at = archetype::find (shstr_depletion);
573 object *tmp;
574 int i;
575 556
557 dynbuf_text &buf = msg_dynbuf; buf.clear ();
558
559 if (!op->is_player ())
560 return 0;
561
562 if (object *race = archetype::find (op->race))
563 buf << " - You are a G<male|female> " << &race->name << ".\n";
564
576 tmp = find_god (determine_god (op)); 565 if (object *god = find_god (determine_god (op)))
577 if (tmp) 566 buf << " - You worship " << &god->name << ".\n";
578 new_draw_info_format (NDI_UNIQUE, 0, op, "You worship %s", &tmp->name);
579 else 567 else
580 new_draw_info (NDI_UNIQUE, 0, op, "You worship no god"); 568 buf << " - You worship no god.\n";
581 569
582 tmp = present_arch_in_ob (at, op); 570 object *tmp = present_arch_in_ob (at, op);
583 571
584 if (*cp == '\0' && tmp == NULL) 572 if (*cp == '\0' && !tmp)
585 new_draw_info (NDI_UNIQUE, 0, op, "You feel very mundane"); 573 buf << " - You feel very mundane. ";
586 else 574 else
587 { 575 {
588 new_draw_info (NDI_UNIQUE, 0, op, "You have:"); 576 buf << " - You have: " << cp << ".\n";
589 new_draw_info (NDI_UNIQUE, 0, op, cp);
590 577
591 if (tmp) 578 if (tmp)
592 for (i = 0; i < NUM_STATS; i++) 579 for (int i = 0; i < NUM_STATS; i++)
593 if (tmp->stats.stat (i) < 0) 580 if (tmp->stats.stat (i) < 0)
594 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is depleted by %d", statname[i], -tmp->stats.stat (i)); 581 buf.printf (" - Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
595 } 582 }
596 583
597 if (is_dragon_pl (op)) 584 if (op->is_dragon ())
598 {
599 /* now grab the 'dragon_ability'-force from the player's inventory */ 585 /* now grab the 'dragon_ability'-force from the player's inventory */
600 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 586 for (tmp = op->inv; tmp; tmp = tmp->below)
601 { 587 {
602 if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force")) 588 if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
603 { 589 {
604 if (tmp->stats.exp == 0) 590 if (tmp->stats.exp == 0)
605 sprintf (buf, "Your metabolism isn't focused on anything."); 591 buf << " - Your metabolism isn't focused on anything.\n";
606 else 592 else
607 sprintf (buf, "Your metabolism is focused on %s.", change_resist_msg[tmp->stats.exp]); 593 buf << " - Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
608 594
609 new_draw_info (NDI_UNIQUE, 0, op, buf);
610 break; 595 break;
611 } 596 }
612 } 597 }
613 } 598
599 op->contr->infobox (MSG_CHANNEL ("perceiveself"), buf);
614 600
615 return 1; 601 return 1;
616} 602}
617 603
618/* This creates magic walls. Really, it can create most any object, 604/* This creates magic walls. Really, it can create most any object,
… …
634 x = op->x; 620 x = op->x;
635 y = op->y; 621 y = op->y;
636 } 622 }
637 else 623 else
638 { 624 {
639 x = op->x + freearr_x[dir]; 625 x = op->x + DIRX (dir);
640 y = op->y + freearr_y[dir]; 626 y = op->y + DIRY (dir);
641 } 627 }
642 628
643 m = op->map; 629 m = op->map;
644 630
645 if ((spell_ob->move_block || x != op->x || y != op->y) && 631 if ((spell_ob->move_block || x != op->x || y != op->y) &&
646 (get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) || 632 (get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) ||
647 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block))) 633 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block)))
648 { 634 {
649 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way."); 635 op->failmsg ("Something is in the way.");
650 return 0; 636 return 0;
651 } 637 }
652 638
653 if (spell_ob->other_arch) 639 if (spell_ob->other_arch)
654 tmp = arch_to_object (spell_ob->other_arch); 640 tmp = spell_ob->other_arch->instance ();
655 else if (spell_ob->race) 641 else if (spell_ob->race)
656 { 642 {
657 char buf1[MAX_BUF]; 643 char buf1[MAX_BUF];
658 644
659 sprintf (buf1, spell_ob->race, dir); 645 sprintf (buf1, spell_ob->race, dir);
… …
663 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1); 649 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);
664 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken."); 650 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");
665 return 0; 651 return 0;
666 } 652 }
667 653
668 tmp = arch_to_object (at); 654 tmp = at->instance ();
669 } 655 }
670 else 656 else
671 { 657 {
672 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name); 658 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);
673 return 0; 659 return 0;
… …
678 tmp->attacktype = spell_ob->attacktype; 664 tmp->attacktype = spell_ob->attacktype;
679 tmp->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 665 tmp->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
680 tmp->stats.dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob); 666 tmp->stats.dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
681 tmp->range = 0; 667 tmp->range = 0;
682 } 668 }
683 else if (QUERY_FLAG (tmp, FLAG_ALIVE)) 669 else if (tmp->flag [FLAG_ALIVE])
684 { 670 {
685 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 671 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
686 tmp->stats.maxhp = tmp->stats.hp; 672 tmp->stats.maxhp = tmp->stats.hp;
687 } 673 }
688 674
689 if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) || QUERY_FLAG (tmp, FLAG_IS_USED_UP)) 675 if (spell_ob->flag [FLAG_IS_USED_UP] || tmp->flag [FLAG_IS_USED_UP])
690 { 676 {
691 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 677 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
692 SET_FLAG (tmp, FLAG_IS_USED_UP); 678 tmp->set_flag (FLAG_IS_USED_UP);
693 } 679 }
694 680
695 if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN)) 681 if (spell_ob->flag [FLAG_TEAR_DOWN])
696 { 682 {
697 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob); 683 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
698 tmp->stats.maxhp = tmp->stats.hp; 684 tmp->stats.maxhp = tmp->stats.hp;
699 SET_FLAG (tmp, FLAG_TEAR_DOWN); 685 tmp->set_flag (FLAG_TEAR_DOWN);
700 SET_FLAG (tmp, FLAG_ALIVE); 686 tmp->set_flag (FLAG_ALIVE);
701 } 687 }
702 688
703 /* This can't really hurt - if the object doesn't kill anything, 689 /* This can't really hurt - if the object doesn't kill anything,
704 * these fields just won't be used. Do not set the owner for 690 * these fields just won't be used. Do not set the owner for
705 * earthwalls, though, so they survive restarts. 691 * earthwalls, though, so they survive restarts.
706 */ 692 */
707 if (tmp->type != EARTHWALL) //TODO 693 if (tmp->type != EARTHWALL) //TODO
708 tmp->set_owner (op); 694 tmp->set_owner (op);
709 695
710 set_spell_skill (op, caster, spell_ob, tmp); 696 set_spell_skill (op, caster, spell_ob, tmp);
711 tmp->level = caster_level (caster, spell_ob) / 2; 697 tmp->level = casting_level (caster, spell_ob) / 2;
712 698
713 name = tmp->name; 699 name = tmp->name;
714 if (!(tmp = m->insert (tmp, x, y, op))) 700 if (!(tmp = m->insert (tmp, x, y, op)))
715 { 701 {
716 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name); 702 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
717 return 0; 703 return 0;
718 } 704 }
719 705
720 /* If this is a spellcasting wall, need to insert the spell object */ 706 /* If this is a spellcasting wall, need to insert the spell object */
721 if (tmp->other_arch && tmp->other_arch->clone.type == SPELL) 707 if (tmp->other_arch && tmp->other_arch->type == SPELL)
722 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp); 708 insert_ob_in_ob (tmp->other_arch->instance (), tmp);
723 709
724 /* This code causes the wall to extend some distance in 710 /* This code causes the wall to extend some distance in
725 * each direction, or until an obstruction is encountered. 711 * each direction, or until an obstruction is encountered.
726 * posblocked and negblocked help determine how far the 712 * posblocked and negblocked help determine how far the
727 * created wall can extend, it won't go extend through 713 * created wall can extend, it won't go extend through
728 * blocked spaces. 714 * blocked spaces.
729 */ 715 */
730 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 716 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
… …
735 { 721 {
736 int dir2; 722 int dir2;
737 723
738 dir2 = (dir < 4) ? (dir + 2) : dir - 2; 724 dir2 = (dir < 4) ? (dir + 2) : dir - 2;
739 725
740 x = tmp->x + i * freearr_x[dir2]; 726 x = tmp->x + i * DIRX (dir2);
741 y = tmp->y + i * freearr_y[dir2]; 727 y = tmp->y + i * DIRY (dir2);
742 m = tmp->map; 728 m = tmp->map;
743 729
744 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) && 730 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
745 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked) 731 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked)
746 { 732 {
747 object *tmp2 = tmp->clone (); 733 object *tmp2 = tmp->clone ();
748 m->insert (tmp2, x, y, op); 734 m->insert (tmp2, x, y, op);
749 735
750 /* If this is a spellcasting wall, need to insert the spell object */ 736 /* If this is a spellcasting wall, need to insert the spell object */
751 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 737 if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
752 tmp2->insert (arch_to_object (tmp2->other_arch)); 738 tmp2->insert (tmp2->other_arch->instance ());
753 739
754 } 740 }
755 else 741 else
756 posblocked = 1; 742 posblocked = 1;
757 743
758 x = tmp->x - i * freearr_x[dir2]; 744 x = tmp->x - i * DIRX (dir2);
759 y = tmp->y - i * freearr_y[dir2]; 745 y = tmp->y - i * DIRY (dir2);
760 m = tmp->map; 746 m = tmp->map;
761 747
762 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) && 748 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
763 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked) 749 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
764 { 750 {
765 object *tmp2 = tmp->clone (); 751 object *tmp2 = tmp->clone ();
766 m->insert (tmp2, x, y, op); 752 m->insert (tmp2, x, y, op);
767 753
768 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 754 if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
769 tmp2->insert (arch_to_object (tmp2->other_arch)); 755 tmp2->insert (tmp2->other_arch->instance ());
770 } 756 }
771 else 757 else
772 negblocked = 1; 758 negblocked = 1;
773 } 759 }
774 760
775 if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW)) 761 if (tmp->flag [FLAG_BLOCKSVIEW])
776 update_all_los (op->map, op->x, op->y); 762 update_all_los (op->map, op->x, op->y);
777 763
778 return 1; 764 return 1;
779} 765}
780 766
781int 767int
782dimension_door (object *op, object *caster, object *spob, int dir) 768dimension_door (object *op, object *caster, object *spob, int dir, const char *spellparam)
783{ 769{
784 uint32 dist, maxdist; 770 uint32 dist, maxdist;
785 int mflags; 771 int mflags;
786 maptile *m; 772 maptile *m;
787 sint16 sx, sy; 773 sint16 sx, sy;
… …
789 if (op->type != PLAYER) 775 if (op->type != PLAYER)
790 return 0; 776 return 0;
791 777
792 if (!dir) 778 if (!dir)
793 { 779 {
794 new_draw_info (NDI_UNIQUE, 0, op, "In what direction?"); 780 op->failmsg ("In what direction?");
795 return 0; 781 return 0;
796 } 782 }
797 783
798 /* Given the new outdoor maps, can't let players dimension door for 784 /* Given the new outdoor maps, can't let players dimension door for
799 * ever, so put limits in. 785 * ever, so put limits in.
800 */ 786 */
801 maxdist = spob->range + SP_level_range_adjust (caster, spob); 787 maxdist = spob->range + SP_level_range_adjust (caster, spob);
802 788
803 if (op->contr->count) 789 if (spellparam)
804 { 790 {
791 int count = atoi (spellparam);
792
805 if (op->contr->count > maxdist) 793 if (count > maxdist)
806 { 794 {
807 new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!"); 795 op->failmsg ("You can't dimension door that far!");
808 return 0; 796 return 0;
809 } 797 }
810 798
811 for (dist = 0; dist < op->contr->count; dist++) 799 for (dist = 0; dist < count; dist++)
812 { 800 {
813 mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy); 801 mflags = get_map_flags (op->map, &m, op->x + DIRX (dir) * (dist + 1), op->y + DIRY (dir) * (dist + 1), &sx, &sy);
814 802
815 if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP)) 803 if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))
816 break; 804 break;
817 805
818 if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))) 806 if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
819 break; 807 break;
820 } 808 }
821 809
822 if (dist < op->contr->count) 810 if (dist < count)
823 { 811 {
824 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n"); 812 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");
825 op->contr->count = 0;
826 return 0; 813 return 0;
827 } 814 }
828
829 op->contr->count = 0;
830 815
831 /* Remove code that puts player on random space on maps. IMO, 816 /* Remove code that puts player on random space on maps. IMO,
832 * a lot of maps probably have areas the player should not get to, 817 * a lot of maps probably have areas the player should not get to,
833 * but may not be marked as NO_MAGIC (as they may be bounded 818 * but may not be marked as NO_MAGIC (as they may be bounded
834 * by such squares). Also, there are probably treasure rooms and 819 * by such squares). Also, there are probably treasure rooms and
835 * lots of other maps that protect areas with no magic, but the 820 * lots of other maps that protect areas with no magic, but the
836 * areas themselves don't contain no magic spaces. 821 * areas themselves don't contain no magic spaces.
837 */ 822 */
838 /* This call here is really just to normalize the coordinates */ 823 /* This call here is really just to normalize the coordinates */
839 mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, &sx, &sy); 824 mflags = get_map_flags (op->map, &m, op->x + DIRX (dir) * dist, op->y + DIRY (dir) * dist, &sx, &sy);
840 if (mflags & P_IS_ALIVE || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))) 825 if (mflags & P_IS_ALIVE || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
841 { 826 {
842 new_draw_info (NDI_UNIQUE, 0, op, "You cast your spell, but nothing happens.\n"); 827 new_draw_info (NDI_UNIQUE, 0, op, "You cast your spell, but nothing happens.\n");
843 return 1; /* Maybe the penalty should be more severe... */ 828 return 1; /* Maybe the penalty should be more severe... */
844 } 829 }
… …
850 * spaces that blocked the players view. 835 * spaces that blocked the players view.
851 */ 836 */
852 837
853 for (dist = 0; dist < maxdist; dist++) 838 for (dist = 0; dist < maxdist; dist++)
854 { 839 {
855 mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy); 840 mflags = get_map_flags (op->map, &m, op->x + DIRX (dir) * (dist + 1), op->y + DIRY (dir) * (dist + 1), &sx, &sy);
856 841
857 if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP)) 842 if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))
858 break; 843 break;
859 844
860 if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))) 845 if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
… …
865 /* If the destination is blocked, keep backing up until we 850 /* If the destination is blocked, keep backing up until we
866 * find a place for the player. 851 * find a place for the player.
867 */ 852 */
868 for (; dist > 0; dist--) 853 for (; dist > 0; dist--)
869 { 854 {
870 if (get_map_flags (op->map, &m, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, 855 if (get_map_flags (op->map, &m, op->x + DIRX (dir) * dist, op->y + DIRY (dir) * dist,
871 &sx, &sy) & (P_OUT_OF_MAP | P_IS_ALIVE)) 856 &sx, &sy) & (P_OUT_OF_MAP | P_IS_ALIVE))
872 continue; 857 continue;
873 858
874 859
875 if (!OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))) 860 if (!OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
876 break; 861 break;
877 862
878 } 863 }
879 if (!dist) 864 if (!dist)
880 { 865 {
881 new_draw_info (NDI_UNIQUE, 0, op, "Your spell failed!\n"); 866 op->failmsg ("Your spell failed!\n");
882 return 0; 867 return 0;
883 } 868 }
884 } 869 }
885 870
886 /* Actually move the player now */ 871 /* Actually move the player now */
887 if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op))) 872 if (!(op = op->map->insert (op, op->x + DIRX (dir) * dist, op->y + DIRY (dir) * dist, op)))
888 return 1; 873 return 1;
889 874
890 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */ 875 op->speed_left = -5. * op->speed; /* Freeze them for a short while */
876
891 return 1; 877 return 1;
892} 878}
893
894 879
895/* cast_heal: Heals something. 880/* cast_heal: Heals something.
896 * op is the caster. 881 * op is the caster.
897 * dir is the direction he is casting it in. 882 * dir is the direction he is casting it in.
898 * spell is the spell object. 883 * spell is the spell object.
… …
925 { 910 {
926 /* See how many points we actually heal. Instead of messages 911 /* See how many points we actually heal. Instead of messages
927 * based on type of spell, we instead do messages based 912 * based on type of spell, we instead do messages based
928 * on amount of damage healed. 913 * on amount of damage healed.
929 */ 914 */
930 if (heal > (tmp->stats.maxhp - tmp->stats.hp)) 915 if (heal > tmp->stats.maxhp - tmp->stats.hp)
931 heal = tmp->stats.maxhp - tmp->stats.hp; 916 heal = tmp->stats.maxhp - tmp->stats.hp;
917
932 tmp->stats.hp += heal; 918 tmp->stats.hp += heal;
933 919
934 if (tmp->stats.hp >= tmp->stats.maxhp) 920 if (tmp->stats.hp >= tmp->stats.maxhp)
935 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!"); 921 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
936 else if (heal > 50) 922 else if (heal > 50)
… …
945 success = 1; 931 success = 1;
946 } 932 }
947 } 933 }
948 934
949 if (spell->attacktype & AT_DISEASE) 935 if (spell->attacktype & AT_DISEASE)
950 if (cure_disease (tmp, op)) 936 if (cure_disease (tmp, op, spell))
951 success = 1; 937 success = 1;
952 938
953 if (spell->attacktype & AT_POISON) 939 if (spell->attacktype & AT_POISON)
954 { 940 {
955 at = archetype::find ("poisoning"); 941 at = archetype::find (shstr_poisoning);
956 poison = present_arch_in_ob (at, tmp); 942 poison = present_arch_in_ob (at, tmp);
957 if (poison) 943 if (poison)
958 { 944 {
959 success = 1; 945 success = 1;
960 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed"); 946 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");
… …
962 } 948 }
963 } 949 }
964 950
965 if (spell->attacktype & AT_CONFUSION) 951 if (spell->attacktype & AT_CONFUSION)
966 { 952 {
967 poison = present_in_ob_by_name (FORCE, "confusion", tmp); 953 poison = present_in_ob_by_name (FORCE, shstr_confusion, tmp);
968 if (poison) 954 if (poison)
969 { 955 {
970 success = 1; 956 success = 1;
971 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 957 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
972 poison->duration = 1; 958 poison->duration = 1;
973 } 959 }
974 } 960 }
975 961
976 if (spell->attacktype & AT_BLIND) 962 if (spell->attacktype & AT_BLIND)
977 { 963 {
978 at = archetype::find ("blindness"); 964 at = archetype::find (shstr_blindness);
979 poison = present_arch_in_ob (at, tmp); 965 poison = present_arch_in_ob (at, tmp);
980 if (poison) 966 if (poison)
981 { 967 {
982 success = 1; 968 success = 1;
983 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return."); 969 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");
… …
1001 tmp->stats.grace = tmp->stats.maxgrace; 987 tmp->stats.grace = tmp->stats.maxgrace;
1002 success = 1; 988 success = 1;
1003 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!"); 989 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");
1004 } 990 }
1005 991
1006 if (spell->stats.food && tmp->stats.food < 999) 992 if (spell->stats.food && tmp->stats.food < MAX_FOOD)
1007 { 993 {
1008 tmp->stats.food += spell->stats.food; 994 tmp->stats.food += spell->stats.food;
1009 if (tmp->stats.food > 999) 995 min_it (tmp->stats.food, MAX_FOOD);
1010 tmp->stats.food = 999; 996
1011 success = 1; 997 success = 1;
1012 /* We could do something a bit better like the messages for healing above */ 998 /* We could do something a bit better like the messages for healing above */
1013 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food"); 999 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1014 } 1000 }
1015 1001
1016 return success; 1002 return success;
1017} 1003}
1018
1019 1004
1020/* This is used for the spells that gain stats. There are no spells 1005/* This is used for the spells that gain stats. There are no spells
1021 * right now that icnrease wis/int/pow on a temp basis, so no 1006 * right now that icnrease wis/int/pow on a temp basis, so no
1022 * good comments for those. 1007 * good comments for those.
1023 */ 1008 */
1024static const char *const no_gain_msgs[NUM_STATS] = { 1009static const char *const no_gain_msgs[NUM_STATS] = {
1025 "You grow no stronger.", 1010 "You grow no stronger.",
1026 "You grow no more agile.", 1011 "You grow no more agile.",
1027 "You don't feel any healthier.", 1012 "You don't feel any healthier.",
1028 "no wis", 1013 "You didn't grow any more intelligent.",
1014 "You do not feel any wiser.",
1015 "You don't feel any more powerful."
1029 "You are no easier to look at.", 1016 "You are no easier to look at.",
1030 "no int",
1031 "no pow"
1032}; 1017};
1033 1018
1034int 1019int
1020change_ability_duration (object *spell, object *caster)
1021{
1022 return spell->duration + SP_level_duration_adjust (caster, spell) * 50;
1023}
1024
1025int
1035cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent) 1026cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1036{ 1027{
1037 object *force = NULL; 1028 object *force = 0;
1038 int i; 1029 int i;
1039 1030
1040 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1031 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1041 object *tmp = dir 1032 object *tmp = dir
1042 ? find_target_for_friendly_spell (op, dir) 1033 ? find_target_for_friendly_spell (op, dir)
1043 : op; 1034 : op;
1044 1035
1045 if (!tmp) 1036 if (!tmp)
1046 return 0; 1037 return 0;
1047 1038
1048 /* If we've already got a force of this type, don't add a new one. */ 1039 /* If we've already got a force of this type, don't add a new one. */
… …
1056 break; 1047 break;
1057 } 1048 }
1058 else if (spell_ob->race && spell_ob->race == tmp2->name) 1049 else if (spell_ob->race && spell_ob->race == tmp2->name)
1059 { 1050 {
1060 if (!silent) 1051 if (!silent)
1061 new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl); 1052 op->failmsgf ("You can not cast %s while %s is in effect",
1053 &spell_ob->name, &tmp2->name_pl);
1054
1062 return 0; 1055 return 0;
1063 } 1056 }
1064 } 1057 }
1065 } 1058 }
1059
1060 int duration = change_ability_duration (spell_ob, caster);
1061
1066 if (force == NULL) 1062 if (force)
1067 {
1068 force = get_archetype (FORCE_NAME);
1069 force->subtype = FORCE_CHANGE_ABILITY;
1070 if (spell_ob->race)
1071 force->name = spell_ob->race;
1072 else
1073 force->name = spell_ob->name;
1074 force->name_pl = spell_ob->name;
1075 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
1076
1077 } 1063 {
1078 else
1079 {
1080 int duration;
1081
1082 duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1083 if (duration > force->duration) 1064 if (duration > force->duration)
1084 { 1065 {
1085 force->duration = duration; 1066 force->duration = duration;
1086 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 1067 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1087 } 1068 }
1088 else 1069 else
1089 {
1090 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect."); 1070 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1091 } 1071
1092 return 1; 1072 return 1;
1093 } 1073 }
1094 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50; 1074
1075 new_draw_info_format (NDI_UNIQUE, 0, op,
1076 "You create an aura of magical force. H<The effect will last for about %.10g seconds.>",
1077 TICK2TIME (duration));
1078
1079 force = archetype::get (FORCE_NAME);
1080 force->subtype = FORCE_CHANGE_ABILITY;
1081 force->duration = duration;
1082
1083 if (spell_ob->race)
1084 force->name = spell_ob->race;
1085 else
1086 force->name = spell_ob->name;
1087
1088 force->name_pl = spell_ob->name;
1089
1095 force->speed = 1.0; 1090 force->speed = 1.0;
1096 force->speed_left = -1.0; 1091 force->speed_left = -1.0;
1097 SET_FLAG (force, FLAG_APPLIED); 1092 force->set_flag (FLAG_APPLIED);
1098 1093
1099 /* Now start processing the effects. First, protections */ 1094 /* Now start processing the effects. First, protections */
1100 for (i = 0; i < NROFATTACKS; i++) 1095 for (i = 0; i < NROFATTACKS; i++)
1101 {
1102 if (spell_ob->resist[i]) 1096 if (spell_ob->resist[i])
1103 {
1104 force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob); 1097 force->resist[i] = min (100, spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob));
1105 if (force->resist[i] > 100) 1098
1106 force->resist[i] = 100;
1107 }
1108 }
1109 if (spell_ob->stats.hp) 1099 if (spell_ob->stats.hp)
1110 force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob); 1100 force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);
1111 1101
1112 if (tmp->type == PLAYER) 1102 if (tmp->type == PLAYER)
1113 { 1103 {
… …
1131 } 1121 }
1132 } 1122 }
1133 1123
1134 force->move_type = spell_ob->move_type; 1124 force->move_type = spell_ob->move_type;
1135 1125
1136 if (QUERY_FLAG (spell_ob, FLAG_SEE_IN_DARK)) 1126 if (spell_ob->flag [FLAG_SEE_IN_DARK])
1137 SET_FLAG (force, FLAG_SEE_IN_DARK); 1127 force->set_flag (FLAG_SEE_IN_DARK);
1138 1128
1139 if (QUERY_FLAG (spell_ob, FLAG_XRAYS)) 1129 if (spell_ob->flag [FLAG_XRAYS])
1140 SET_FLAG (force, FLAG_XRAYS); 1130 force->set_flag (FLAG_XRAYS);
1141 1131
1142 /* Haste/bonus speed */ 1132 /* Haste/bonus speed */
1143 if (spell_ob->stats.exp) 1133 if (spell_ob->stats.exp)
1144 { 1134 {
1145 if (op->speed > 0.5f) 1135 if (op->speed > 0.5f)
… …
1153 force->attacktype = spell_ob->attacktype; 1143 force->attacktype = spell_ob->attacktype;
1154 1144
1155 insert_ob_in_ob (force, tmp); 1145 insert_ob_in_ob (force, tmp);
1156 change_abil (tmp, force); /* Mostly to display any messages */ 1146 change_abil (tmp, force); /* Mostly to display any messages */
1157 tmp->update_stats (); 1147 tmp->update_stats ();
1148
1158 return 1; 1149 return 1;
1159} 1150}
1160 1151
1161/* This used to be part of cast_change_ability, but it really didn't make 1152/* This used to be part of cast_change_ability, but it really didn't make
1162 * a lot of sense, since most of the values it derives are from the god 1153 * a lot of sense, since most of the values it derives are from the god
1163 * of the caster. 1154 * of the caster.
1164 */ 1155 */
1165
1166int 1156int
1167cast_bless (object *op, object *caster, object *spell_ob, int dir) 1157cast_bless (object *op, object *caster, object *spell_ob, int dir)
1168{ 1158{
1169 int i; 1159 int i;
1170 object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp; 1160 object *god = find_god (determine_god (op)), *force = NULL, *tmp;
1171 1161
1172 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1162 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1173 if (dir != 0) 1163 if (dir != 0)
1174 { 1164 {
1175 tmp = find_target_for_friendly_spell (op, dir); 1165 tmp = find_target_for_friendly_spell (op, dir);
1166
1167 if (!tmp)
1168 return 0;
1176 } 1169 }
1177 else 1170 else
1178 {
1179 tmp = op; 1171 tmp = op;
1180 }
1181 1172
1182 /* If we've already got a force of this type, don't add a new one. */ 1173 /* If we've already got a force of this type, don't add a new one. */
1183 for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below) 1174 for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1184 { 1175 {
1185 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY) 1176 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1186 { 1177 {
1187 if (tmp2->name == spell_ob->name) 1178 if (tmp2->name == spell_ob->name)
1188 { 1179 {
… …
1194 new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl); 1185 new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);
1195 return 0; 1186 return 0;
1196 } 1187 }
1197 } 1188 }
1198 } 1189 }
1190
1199 if (force == NULL) 1191 if (force == NULL)
1200 { 1192 {
1201 force = get_archetype (FORCE_NAME); 1193 force = archetype::get (FORCE_NAME);
1202 force->subtype = FORCE_CHANGE_ABILITY; 1194 force->subtype = FORCE_CHANGE_ABILITY;
1203 if (spell_ob->race) 1195 if (spell_ob->race)
1204 force->name = spell_ob->race; 1196 force->name = spell_ob->race;
1205 else 1197 else
1206 force->name = spell_ob->name; 1198 force->name = spell_ob->name;
… …
1221 { 1213 {
1222 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect."); 1214 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1223 } 1215 }
1224 return 0; 1216 return 0;
1225 } 1217 }
1218
1226 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50; 1219 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1227 force->speed = 1.0; 1220 force->speed = 1.0;
1228 force->speed_left = -1.0; 1221 force->speed_left = -1.0;
1229 SET_FLAG (force, FLAG_APPLIED); 1222 force->set_flag (FLAG_APPLIED);
1230 1223
1231 if (!god) 1224 if (!god)
1232 { 1225 {
1233 new_draw_info (NDI_UNIQUE, 0, op, "Your blessing seems empty."); 1226 new_draw_info (NDI_UNIQUE, 0, op, "Your blessing seems empty.");
1234 } 1227 }
1235 else 1228 else
1236 { 1229 {
1237 /* Only give out good benefits, and put a max on it */ 1230 /* Only give out good benefits, and put a max on it */
1238 for (i = 0; i < NROFATTACKS; i++) 1231 for (i = 0; i < NROFATTACKS; i++)
1239 {
1240 if (god->resist[i] > 0) 1232 if (god->resist[i] > 0)
1241 {
1242 force->resist[i] = MIN (god->resist[i], spell_ob->resist[ATNR_GODPOWER]); 1233 force->resist[i] = min (god->resist[i], spell_ob->resist[ATNR_GODPOWER]);
1243 } 1234
1244 }
1245 force->path_attuned |= god->path_attuned; 1235 force->path_attuned |= god->path_attuned;
1246 1236
1247 if (spell_ob->attacktype) 1237 if (spell_ob->attacktype)
1248 force->slaying = god->slaying; 1238 force->slaying = god->slaying;
1249 1239
… …
1268} 1258}
1269 1259
1270/* Alchemy code by Mark Wedel 1260/* Alchemy code by Mark Wedel
1271 * 1261 *
1272 * This code adds a new spell, called alchemy. Alchemy will turn 1262 * This code adds a new spell, called alchemy. Alchemy will turn
1273 * objects to gold nuggets, the value of the gold nuggets being 1263 * objects to pyrite ("false gold"), henceforth called gold nuggets.
1274 * about 90% of that of the item itself. It uses the value of the
1275 * object before charisma adjustments, because the nuggets themselves
1276 * will be will be adjusted by charisma when sold.
1277 * 1264 *
1278 * Large nuggets are worth 25 gp each (base). You will always get 1265 * The value of the gold nuggets being about 90% of that of the item
1279 * the maximum number of large nuggets you could get. 1266 * itself. It uses the value of the object before charisma adjustments,
1280 * Small nuggets are worth 1 gp each (base). You will get from 0 1267 * because the nuggets themselves will be will be adjusted by charisma
1281 * to the max amount of small nuggets as you could get. 1268 * when sold.
1282 *
1283 * For example, if an item is worth 110 gold, you will get
1284 * 4 large nuggets, and from 0-10 small nuggets.
1285 * 1269 *
1286 * There is also a chance (1:30) that you will get nothing at all 1270 * There is also a chance (1:30) that you will get nothing at all
1287 * for the object. There is also a maximum weight that will be 1271 * for the object. There is also a maximum weight that will be
1288 * alchemised. 1272 * alchemised.
1289 */ 1273 */
1290static void 1274static void
1291alchemy_object (object *obj, uint64 &total_value, int &total_weight) 1275alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1292{ 1276{
1293 uint64 value = query_cost (obj, NULL, F_TRUE); 1277 uint64 value = query_cost (obj, NULL, F_TRUE);
1294 1278
1295 /* Give third price when we alchemy money (This should hopefully 1279 /* Give third price when we alchemy money (this should hopefully
1296 * make it so that it isn't worth it to alchemy money, sell 1280 * make it so that it isn't worth it to alchemy money, sell
1297 * the nuggets, alchemy the gold from that, etc. 1281 * the nuggets, alchemy the gold from that, etc.
1298 * Otherwise, give 9 silver on the gold for other objects, 1282 * Otherwise, give 9 silver on the gold for other objects,
1299 * so that it would still be more affordable to haul 1283 * so that it would still be more affordable to haul
1300 * the stuff back to town. 1284 * the stuff back to town.
1301 */ 1285 */
1302 if (QUERY_FLAG (obj, FLAG_UNPAID)) 1286 if (obj->flag [FLAG_UNPAID])
1303 value = 0; 1287 value = 0;
1304 else if (obj->type == MONEY || obj->type == GEM) 1288 else if (obj->type == MONEY || obj->type == GEM)
1305 value /= 3; 1289 value /= 3;
1306 else 1290 else
1307 value = value * 9 / 10; 1291 value = value * 9 / 10;
… …
1312 total_weight += obj->total_weight (); 1296 total_weight += obj->total_weight ();
1313 1297
1314 obj->destroy (); 1298 obj->destroy ();
1315} 1299}
1316 1300
1317static void
1318update_map (object *op, maptile *m, int small_nuggets, object *small, int large_nuggets, object *large, int x, int y)
1319{
1320 int flag = 0;
1321
1322 /* Put any nuggets below the player, but we can only pass this
1323 * flag if we are on the same space as the player
1324 */
1325 if (x == op->x && y == op->y && op->map == m)
1326 flag = INS_BELOW_ORIGINATOR;
1327
1328 if (small_nuggets)
1329 {
1330 object *tmp = small->clone ();
1331 tmp->nrof = small_nuggets;
1332 m->insert (tmp, x, y, op, flag);
1333 }
1334
1335 if (large_nuggets)
1336 {
1337 object *tmp = large->clone ();
1338 tmp->nrof = large_nuggets;
1339 m->insert (tmp, x, y, op, flag);
1340 }
1341
1342 if (object *pl = m->at (x, y).player ())
1343 if (pl->contr->ns)
1344 pl->contr->ns->look_position = 0;
1345}
1346
1347int 1301int
1348alchemy (object *op, object *caster, object *spell_ob) 1302alchemy (object *op, object *caster, object *spell_ob)
1349{ 1303{
1350 if (op->type != PLAYER) 1304 if (op->type != PLAYER)
1351 return 0; 1305 return 0;
1352 1306
1353 object *large = get_archetype ("largenugget"); 1307 archetype *nugget[3];
1354 object *small = get_archetype ("smallnugget"); 1308
1309 nugget[0] = archetype::find (shstr_pyrite3);
1310 nugget[1] = archetype::find (shstr_pyrite2);
1311 nugget[2] = archetype::find (shstr_pyrite);
1355 1312
1356 /* Put a maximum weight of items that can be alchemised. Limits the power 1313 /* Put a maximum weight of items that can be alchemised. Limits the power
1357 * some, and also prevents people from alchemising every table/chair/clock 1314 * some, and also prevents people from alchemising every table/chair/clock
1358 * in sight 1315 * in sight
1359 */ 1316 */
… …
1388 1345
1389 for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next) 1346 for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next)
1390 { 1347 {
1391 next = tmp->above; 1348 next = tmp->above;
1392 1349
1393 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) && 1350 if (tmp->weight > 0 && !tmp->flag [FLAG_NO_PICK] &&
1394 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON)) 1351 !tmp->flag [FLAG_ALIVE] && !tmp->flag [FLAG_IS_CAULDRON])
1395 { 1352 {
1396 if (tmp->inv) 1353 if (tmp->inv)
1397 { 1354 {
1398 object *next1, *tmp1; 1355 object *next1, *tmp1;
1399 1356
1400 for (tmp1 = tmp->inv; tmp1; tmp1 = next1) 1357 for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1401 { 1358 {
1402 next1 = tmp1->below; 1359 next1 = tmp1->below;
1403 if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) && 1360 if (tmp1->weight > 0 && !tmp1->flag [FLAG_NO_PICK] &&
1404 !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON)) 1361 !tmp1->flag [FLAG_ALIVE] && !tmp1->flag [FLAG_IS_CAULDRON])
1405 alchemy_object (tmp1, value, weight); 1362 alchemy_object (tmp1, value, weight);
1406 } 1363 }
1407 } 1364 }
1408 1365
1409 alchemy_object (tmp, value, weight); 1366 alchemy_object (tmp, value, weight);
… …
1411 if (weight > weight_max) 1368 if (weight > weight_max)
1412 break; 1369 break;
1413 } 1370 }
1414 } 1371 }
1415 1372
1373 value -= rndm (value >> 4);
1416 value = min (value, value_max); 1374 value = min (value, value_max);
1417 1375
1418 uint64 count = value / large->value; 1376 for (int i = 0; i < array_length (nugget); ++i)
1419 int large_nuggets = count; 1377 if (int nrof = value / nugget [i]->value)
1420 value -= count * large->value;
1421
1422 count = value / small->value;
1423 int small_nuggets = count;
1424
1425 /* Insert all the nuggets at one time. This probably saves time, but
1426 * it also prevents us from alcheming nuggets that were just created
1427 * with this spell.
1428 */ 1378 {
1429 update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny); 1379 value -= nrof * nugget[i]->value;
1380
1381 object *tmp = nugget[i]->instance ();
1382 tmp->nrof = nrof;
1383 tmp->flag [FLAG_IDENTIFIED] = true;
1384 op->map->insert (tmp, x, y, op, 0);
1385 }
1430 1386
1431 if (weight > weight_max) 1387 if (weight > weight_max)
1432 goto bailout; 1388 goto bailout;
1433 } 1389 }
1434 } 1390 }
1435 1391
1436bailout: 1392bailout:
1437 large->destroy ();
1438 small->destroy ();
1439 return 1; 1393 return 1;
1440} 1394}
1441
1442 1395
1443/* This function removes the cursed/damned status on equipped 1396/* This function removes the cursed/damned status on equipped
1444 * items. 1397 * items.
1445 */ 1398 */
1446int 1399int
1447remove_curse (object *op, object *caster, object *spell) 1400remove_curse (object *op, object *caster, object *spell)
1448{ 1401{
1449 object *tmp;
1450 int success = 0, was_one = 0; 1402 int success = 0, was_one = 0;
1451 1403
1404 int num_uncurse = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
1405
1406 op->splay_marked ();
1407
1408 int typeflag = spell->last_sp ? FLAG_DAMNED : FLAG_CURSED;
1409
1452 for (tmp = op->inv; tmp; tmp = tmp->below) 1410 for (object *tmp = op->inv; tmp && num_uncurse; tmp = tmp->below)
1453 if (QUERY_FLAG (tmp, FLAG_APPLIED) && 1411 if (!tmp->invisible && tmp->flag [typeflag])
1454 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
1455 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
1456 { 1412 {
1457 was_one++; 1413 ++was_one;
1414
1458 if (tmp->level <= caster_level (caster, spell)) 1415 if (tmp->level <= casting_level (caster, spell))
1459 { 1416 {
1460 success++; 1417 ++success;
1461 if (QUERY_FLAG (spell, FLAG_DAMNED)) 1418 --num_uncurse;
1462 CLEAR_FLAG (tmp, FLAG_DAMNED);
1463 1419
1464 CLEAR_FLAG (tmp, FLAG_CURSED); 1420 tmp->clr_flag (typeflag);
1465 CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED); 1421 tmp->clr_flag (FLAG_CURSED);
1422 tmp->clr_flag (FLAG_KNOWN_CURSED);
1466 tmp->value = 0; /* Still can't sell it */ 1423 tmp->value = 0; /* Still can't sell it */
1467 if (op->type == PLAYER) 1424
1425 if (object *pl = tmp->visible_to ())
1468 esrv_send_item (op, tmp); 1426 esrv_update_item (UPD_FLAGS, pl, tmp);
1469 } 1427 }
1470 } 1428 }
1471 1429
1472 if (op->type == PLAYER) 1430 if (op->type == PLAYER)
1473 { 1431 {
1474 if (success) 1432 if (success)
1475 new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now."); 1433 new_draw_info (NDI_UNIQUE, 0, op, "You realise that some of your items look shinier now. H<You successfully removed some curses.>");
1476 else 1434 else
1477 { 1435 {
1478 if (was_one) 1436 if (was_one)
1479 new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse."); 1437 new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove any curse. H<The spell was not strong enough.>");
1480 else 1438 else
1481 new_draw_info (NDI_UNIQUE, 0, op, "You are not using any cursed items."); 1439 new_draw_info (NDI_UNIQUE, 0, op, "You are not having any cursed items. H<Epic fail.>");
1482 } 1440 }
1483 } 1441 }
1484 1442
1485 return success; 1443 return success;
1486} 1444}
1487 1445
1488/* Identifies objects in the players inventory/on the ground */ 1446/* Identifies objects in the players inventory/on the ground */
1489
1490int 1447int
1491cast_identify (object *op, object *caster, object *spell) 1448cast_identify (object *op, object *caster, object *spell)
1492{ 1449{
1493 object *tmp; 1450 dynbuf_text &buf = msg_dynbuf; buf.clear ();
1494 int success = 0, num_ident;
1495 1451
1496 num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1452 int num_ident = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
1497 1453
1498 if (num_ident < 1) 1454 op->splay_marked ();
1499 num_ident = 1;
1500 1455
1501 for (tmp = op->inv; tmp; tmp = tmp->below) 1456 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1502 { 1457 {
1503 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1458 if (!tmp->flag [FLAG_IDENTIFIED] && !tmp->invisible && tmp->need_identify ())
1504 { 1459 {
1505 identify (tmp); 1460 identify (tmp);
1506 1461
1507 if (op->type == PLAYER) 1462 if (op->type == PLAYER)
1508 { 1463 {
1509 new_draw_info_format (NDI_UNIQUE, 0, op, "You identified: %s.", long_desc (tmp, op)); 1464 buf.printf ("You identified: %s.\r", long_desc (tmp, op));
1510 1465
1511 if (tmp->msg) 1466 if (tmp->msg)
1512 { 1467 buf << "The item has a story:\r" << tmp->msg << "\n\n";
1513 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1514 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1515 }
1516 } 1468 }
1517 1469
1518 num_ident--;
1519 success = 1;
1520 if (!num_ident) 1470 if (!--num_ident)
1521 break; 1471 break;
1522 } 1472 }
1523 } 1473 }
1524 1474
1525 /* If all the power of the spell has been used up, don't go and identify 1475 /* If all the power of the spell has been used up, don't go and identify
1526 * stuff on the floor. Only identify stuff on the floor if the spell 1476 * stuff on the floor. Only identify stuff on the floor if the spell
1527 * was not fully used. 1477 * was not fully used.
1528 */ 1478 */
1529 if (num_ident) 1479 if (num_ident)
1530 { 1480 {
1531 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above) 1481 for (object *tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1532 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1482 if (!tmp->flag [FLAG_IDENTIFIED] && !tmp->invisible && tmp->need_identify ())
1533 { 1483 {
1534 identify (tmp); 1484 identify (tmp);
1535 1485
1536 if (op->type == PLAYER) 1486 if (object *pl = tmp->visible_to ())
1537 { 1487 {
1538 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground you identified: %s.", long_desc (tmp, op)); 1488 buf.printf ("On the ground you identified: %s.\r", long_desc (tmp, op));
1539 1489
1540 if (tmp->msg) 1490 if (tmp->msg)
1541 { 1491 buf << "The item has a story:\r" << tmp->msg << "\n\n";
1542 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1543 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1544 }
1545
1546 esrv_send_item (op, tmp);
1547 } 1492 }
1548 1493
1549 num_ident--;
1550 success = 1;
1551 if (!num_ident) 1494 if (!--num_ident)
1552 break; 1495 break;
1553 } 1496 }
1554 } 1497 }
1555 1498
1556 if (!success) 1499 if (buf.empty ())
1557 new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified."); 1500 {
1501 op->failmsg ("You can't reach anything unidentified.");
1502 return 0;
1503 }
1558 else 1504 else
1505 {
1506 if (op->contr)
1507 op->contr->infobox (MSG_CHANNEL ("identify"), buf);
1508
1559 spell_effect (spell, op->x, op->y, op->map, op); 1509 spell_effect (spell, op->x, op->y, op->map, op);
1560 1510 return 1;
1561 return success; 1511 }
1562} 1512}
1563 1513
1564int 1514int
1565cast_detection (object *op, object *caster, object *spell, object *skill) 1515cast_detection (object *op, object *caster, object *spell, object *skill)
1566{ 1516{
1567 object *tmp, *last, *god, *detect; 1517 object *tmp, *last, *god, *detect;
1568 int done_one, range, mflags, floor, level; 1518 int done_one, range, floor, level;
1569 sint16 x, y, nx, ny; 1519 sint16 x, y, nx, ny;
1570 maptile *m; 1520 maptile *m;
1571 1521
1572 /* We precompute some values here so that we don't have to keep 1522 /* We precompute some values here so that we don't have to keep
1573 * doing it over and over again. 1523 * doing it over and over again.
1574 */ 1524 */
1575 god = find_god (determine_god (op)); 1525 god = find_god (determine_god (op));
1576 level = caster_level (caster, spell); 1526 level = casting_level (caster, spell);
1577 range = spell->range + SP_level_range_adjust (caster, spell); 1527 range = spell->range + SP_level_range_adjust (caster, spell);
1578 1528
1579 if (!skill) 1529 if (!skill)
1580 skill = caster; 1530 skill = caster;
1581 1531
1582 for (x = op->x - range; x <= op->x + range; x++) 1532 dynbuf buf;
1583 for (y = op->y - range; y <= op->y + range; y++) 1533 unordered_mapwalk (buf, op, -range, -range, range, range)
1584 { 1534 {
1585 m = op->map;
1586 mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1587 if (mflags & P_OUT_OF_MAP)
1588 continue;
1589
1590 /* For most of the detections, we only detect objects above the 1535 /* For most of the detections, we only detect objects above the
1591 * floor. But this is not true for show invisible. 1536 * floor. But this is not true for show invisible.
1592 * Basically, we just go and find the top object and work 1537 * Basically, we just go and find the top object and work
1593 * down - that is easier than working up. 1538 * down - that is easier than working up.
1594 */ 1539 */
1595 1540
1596 for (last = NULL, tmp = GET_MAP_OB (m, nx, ny); tmp; tmp = tmp->above) 1541 for (last = 0, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)
1597 last = tmp; 1542 last = tmp;
1598 1543
1599 /* Shouldn't happen, but if there are no objects on a space, this 1544 /* Shouldn't happen, but if there are no objects on a space, this
1600 * would happen. 1545 * would happen.
1601 */ 1546 */
1602 if (!last) 1547 if (!last)
1603 continue; 1548 continue;
1604 1549
1605 done_one = 0; 1550 done_one = 0;
1606 floor = 0; 1551 floor = 0;
1607 detect = NULL; 1552 detect = 0;
1608 for (tmp = last; tmp; tmp = tmp->below) 1553 for (tmp = last; tmp; tmp = tmp->below)
1609 { 1554 {
1610 /* show invisible */ 1555 /* show invisible */
1611 if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) && 1556 if (spell->flag [FLAG_MAKE_INVIS]
1612 /* Might there be other objects that we can make visible? */ 1557 /* Might there be other objects that we can make visible? */
1613 (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) || 1558 && (tmp->invisible && (tmp->flag [FLAG_MONSTER]
1614 (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) || 1559 || (tmp->type == PLAYER && !tmp->flag [FLAG_WIZ])
1615 tmp->type == CF_HANDLE || 1560 || tmp->type == T_HANDLE
1616 tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE || 1561 || tmp->type == TRAPDOOR
1562 || tmp->type == EXIT
1563 || tmp->type == HOLE
1564 || tmp->type == BUTTON
1617 tmp->type == BUTTON || tmp->type == TELEPORTER || 1565 || tmp->type == TELEPORTER
1566 || tmp->type == GATE
1618 tmp->type == GATE || tmp->type == LOCKED_DOOR || 1567 || tmp->type == LOCKED_DOOR
1619 tmp->type == WEAPON || tmp->type == ALTAR || tmp->type == SIGN || 1568 || tmp->type == WEAPON
1569 || tmp->type == ALTAR
1570 || (tmp->type == SIGN && tmp->face != magicmouth_face)
1620 tmp->type == TRIGGER_PEDESTAL || tmp->type == SPECIAL_KEY || 1571 || tmp->type == TRIGGER_PEDESTAL
1621 tmp->type == TREASURE || tmp->type == BOOK || tmp->type == HOLY_ALTAR))) 1572 || tmp->type == SPECIAL_KEY
1573 || tmp->type == TREASURE
1574 || tmp->type == BOOK
1575 || tmp->type == HOLY_ALTAR
1576 || tmp->type == CONTAINER)))
1622 { 1577 {
1578 printf ("show inv %s\n", tmp->debug_desc());//D
1623 if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4) 1579 if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)
1624 { 1580 {
1625 tmp->invisible = 0; 1581 tmp->invisible = 0;
1582 done_one = 1;
1583 }
1584 }
1585
1586 if (tmp->flag [FLAG_IS_FLOOR])
1587 floor = 1;
1588
1589 /* All detections below this point don't descend beneath the floor,
1590 * so just continue on. We could be clever and look at the type of
1591 * detection to completely break out if we don't care about objects beneath
1592 * the floor, but once we get to the floor, not likely a very big issue anyways.
1593 */
1594 if (floor)
1595 continue;
1596
1597 /* I had thought about making detect magic and detect curse
1598 * show the flash the magic item like it does for detect monster.
1599 * however, if the object is within sight, this would then make it
1600 * difficult to see what object is magical/cursed, so the
1601 * effect wouldn't be as apparent.
1602 */
1603
1604 /* detect magic */
1605 if (spell->flag [FLAG_KNOWN_MAGICAL]
1606 && !tmp->flag [FLAG_KNOWN_MAGICAL]
1607 && !tmp->flag [FLAG_IDENTIFIED]
1608 && tmp->need_identify ()
1609 && is_magical (tmp))
1610 {
1611 tmp->set_flag (FLAG_KNOWN_MAGICAL);
1612 /* make runes more visible */
1613 if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1614 tmp->stats.Cha /= 4;
1615
1616 done_one = 1;
1617 }
1618
1619 /* detect monster */
1620 if (spell->flag [FLAG_MONSTER] && (tmp->flag [FLAG_MONSTER] || tmp->type == PLAYER))
1621 {
1622 done_one = 2;
1623
1624 if (!detect)
1625 detect = tmp;
1626 }
1627
1628 /* Basically, if race is set in the spell, then the creatures race must
1629 * match that. if the spell race is set to GOD, then the gods opposing
1630 * race must match.
1631 */
1632 if (spell->race && tmp->flag [FLAG_MONSTER] && tmp->race &&
1633 ((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) ||
1634 spell->race.contains (tmp->race)))
1635 {
1636 done_one = 2;
1637
1638 if (!detect)
1639 detect = tmp;
1640 }
1641
1642 if (spell->flag [FLAG_KNOWN_CURSED]
1643 && !tmp->flag [FLAG_KNOWN_CURSED]
1644 && tmp->need_identify ()
1645 && (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED]))
1646 {
1647 tmp->set_flag (FLAG_KNOWN_CURSED);
1648 done_one = 1;
1649 }
1650
1651 // Do mining detection spell:
1652 if (spell->last_sp == 1) // 1 - detect any vein
1653 {
1654 if (tmp->type == VEIN)
1655 {
1656 if (tmp->other_arch)
1657 {
1658 if (!detect)
1659 detect = tmp->other_arch;
1660 done_one = 2;
1661 }
1662 else
1626 done_one = 1; 1663 done_one = 1;
1627 } 1664 }
1628 } 1665 }
1629
1630 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1631 floor = 1;
1632
1633 /* All detections below this point don't descend beneath the floor,
1634 * so just continue on. We could be clever and look at the type of
1635 * detection to completely break out if we don't care about objects beneath
1636 * the floor, but once we get to the floor, not likely a very big issue anyways.
1637 */
1638 if (floor)
1639 continue;
1640
1641 /* I had thought about making detect magic and detect curse
1642 * show the flash the magic item like it does for detect monster.
1643 * however, if the object is within sight, this would then make it
1644 * difficult to see what object is magical/cursed, so the
1645 * effect wouldn't be as apparant.
1646 */
1647
1648 /* detect magic */
1649 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&
1650 !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))
1651 {
1652 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1653 /* make runes more visibile */
1654 if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1655 tmp->stats.Cha /= 4;
1656 done_one = 1;
1657 }
1658 /* detect monster */
1659 if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))
1660 {
1661 done_one = 2;
1662 if (!detect)
1663 detect = tmp;
1664 }
1665 /* Basically, if race is set in the spell, then the creatures race must
1666 * match that. if the spell race is set to GOD, then the gods opposing
1667 * race must match.
1668 */
1669 if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&
1670 ((!strcmp (spell->race, "GOD") && god && god->slaying && strstr (god->slaying, tmp->race)) ||
1671 (strstr (spell->race, tmp->race))))
1672 {
1673 done_one = 2;
1674 if (!detect)
1675 detect = tmp;
1676 }
1677 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1678 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1679 {
1680 SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1681 done_one = 1;
1682 }
1683 } /* for stack of objects on this space */ 1666 } /* for stack of objects on this space */
1684 1667
1685 /* Code here puts an effect of the spell on the space, so you can see 1668 /* Code here puts an effect of the spell on the space, so you can see
1686 * where the magic is. 1669 * where the magic is.
1687 */ 1670 */
1688 if (done_one) 1671 if (done_one)
1689 { 1672 {
1690 object *detect_ob = arch_to_object (spell->other_arch); 1673 object *detect_ob = spell->other_arch->instance ();
1691 1674
1692 /* if this is set, we want to copy the face */ 1675 /* if this is set, we want to copy the face */
1693 if (done_one == 2 && detect) 1676 if (done_one == 2 && detect)
1694 { 1677 {
1695 detect_ob->face = detect->face; 1678 detect_ob->face = detect->face;
1696 detect_ob->animation_id = detect->animation_id; 1679 detect_ob->animation_id = detect->animation_id;
1697 detect_ob->anim_speed = detect->anim_speed; 1680 detect_ob->anim_speed = detect->anim_speed;
1698 detect_ob->last_anim = 0; 1681 detect_ob->last_anim = 0;
1699 /* by default, the detect_ob is already animated */ 1682 /* by default, the detect_ob is already animated */
1700 if (!QUERY_FLAG (detect, FLAG_ANIMATE)) 1683 if (!detect->flag [FLAG_ANIMATE])
1701 CLEAR_FLAG (detect_ob, FLAG_ANIMATE); 1684 detect_ob->clr_flag (FLAG_ANIMATE);
1702 } 1685 }
1703 1686
1704 m->insert (detect_ob, nx, ny, op); 1687 m->insert (detect_ob, nx, ny, op, INS_ON_TOP);
1705 } 1688 }
1706 } /* for processing the surrounding spaces */ 1689 } /* for processing the surrounding spaces */
1707 1690
1708 1691
1709 /* Now process objects in the players inventory if detect curse or magic */ 1692 /* Now process objects in the players inventory if detect curse or magic */
1710 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL)) 1693 if (spell->flag [FLAG_KNOWN_CURSED] || spell->flag [FLAG_KNOWN_MAGICAL])
1711 { 1694 {
1712 done_one = 0; 1695 done_one = 0;
1696
1713 for (tmp = op->inv; tmp; tmp = tmp->below) 1697 for (tmp = op->inv; tmp; tmp = tmp->below)
1714 { 1698 {
1715 if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED)) 1699 if (!tmp->invisible && !tmp->flag [FLAG_IDENTIFIED])
1716 { 1700 {
1717 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL)) 1701 if (spell->flag [FLAG_KNOWN_MAGICAL] && is_magical (tmp) && !tmp->flag [FLAG_KNOWN_MAGICAL])
1718 { 1702 {
1719 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL); 1703 tmp->set_flag (FLAG_KNOWN_MAGICAL);
1720 if (op->type == PLAYER) 1704
1705 if (object *pl = tmp->visible_to ())
1721 esrv_send_item (op, tmp); 1706 esrv_update_item (UPD_FLAGS, pl, tmp);
1722 } 1707 }
1723 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) && 1708
1724 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))) 1709 if (spell->flag [FLAG_KNOWN_CURSED] && !tmp->flag [FLAG_KNOWN_CURSED] &&
1710 (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED]))
1725 { 1711 {
1726 SET_FLAG (tmp, FLAG_KNOWN_CURSED); 1712 tmp->set_flag (FLAG_KNOWN_CURSED);
1727 if (op->type == PLAYER) 1713
1714 if (object *pl = tmp->visible_to ())
1728 esrv_send_item (op, tmp); 1715 esrv_update_item (UPD_FLAGS, pl, tmp);
1729 } 1716 }
1730 } /* if item is not identified */ 1717 } /* if item is not identified */
1731 } /* for the players inventory */ 1718 } /* for the players inventory */
1732 } /* if detect magic/curse and object is a player */ 1719 } /* if detect magic/curse and object is a player */
1720
1733 return 1; 1721 return 1;
1734} 1722}
1735 1723
1736 1724
1737/** 1725/**
… …
1750 1738
1751 new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you."); 1739 new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you.");
1752 1740
1753 if (victim->stats.sp >= victim->stats.maxsp * 2) 1741 if (victim->stats.sp >= victim->stats.maxsp * 2)
1754 { 1742 {
1755 object *tmp;
1756
1757 new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!"); 1743 new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!");
1758
1759 /* Explodes a fireball centered at player */
1760 tmp = get_archetype (EXPLODING_FIREBALL);
1761 tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
1762 tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
1763
1764 tmp->insert_at (victim);
1765 victim->stats.sp = 2 * victim->stats.maxsp; 1744 victim->stats.sp = 2 * victim->stats.maxsp;
1745 create_exploding_ball_at (victim, caster_level);
1766 } 1746 }
1767 else if (victim->stats.sp >= victim->stats.maxsp * 1.88) 1747 else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
1768 new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode."); 1748 new_draw_info (NDI_UNIQUE | NDI_ORANGE, 0, victim, "You feel like your head is going to explode.");
1769 else if (victim->stats.sp >= victim->stats.maxsp * 1.66) 1749 else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
1770 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!"); 1750 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
1771 else if (victim->stats.sp >= victim->stats.maxsp * 1.5) 1751 else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
1772 { 1752 {
1773 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world."); 1753 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
… …
1789 sint16 x, y; 1769 sint16 x, y;
1790 maptile *m; 1770 maptile *m;
1791 int mflags; 1771 int mflags;
1792 1772
1793 m = op->map; 1773 m = op->map;
1794 x = op->x + freearr_x[dir]; 1774 x = op->x + DIRX (dir);
1795 y = op->y + freearr_y[dir]; 1775 y = op->y + DIRY (dir);
1796 1776
1797 mflags = get_map_flags (m, &m, x, y, &x, &y); 1777 mflags = get_map_flags (m, &m, x, y, &x, &y);
1798 1778
1799 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE) 1779 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
1800 { 1780 {
1801 for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above) 1781 for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above)
1802 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 1782 if (plyr != op && plyr->flag [FLAG_ALIVE])
1803 break; 1783 break;
1804 } 1784 }
1805 1785
1806 1786
1807 /* If we did not find a player in the specified direction, transfer 1787 /* If we did not find a player in the specified direction, transfer
1808 * to anyone on top of us. This is used for the rune of transference mostly. 1788 * to anyone on top of us. This is used for the rune of transference mostly.
1809 */ 1789 */
1810 if (plyr == NULL) 1790 if (plyr == NULL)
1811 for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above) 1791 for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above)
1812 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 1792 if (plyr != op && plyr->flag [FLAG_ALIVE])
1813 break; 1793 break;
1814 1794
1815 if (!plyr) 1795 if (!plyr)
1816 { 1796 {
1817 new_draw_info (NDI_BLACK, 0, op, "There is no one there."); 1797 op->failmsg ("There is no one there.");
1818 return 0; 1798 return 0;
1819 } 1799 }
1820 /* give sp */ 1800 /* give sp */
1821 if (spell->stats.dam > 0) 1801 if (spell->stats.dam > 0)
1822 { 1802 {
1823 plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell); 1803 plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell);
1824 charge_mana_effect (plyr, caster_level (caster, spell)); 1804 charge_mana_effect (plyr, casting_level (caster, spell));
1825 return 1; 1805 return 1;
1826 } 1806 }
1827 /* suck sp away. Can't suck sp from yourself */ 1807 /* suck sp away. Can't suck sp from yourself */
1828 else if (op != plyr) 1808 else if (op != plyr)
1829 { 1809 {
… …
1834 if (rate > 95) 1814 if (rate > 95)
1835 rate = 95; 1815 rate = 95;
1836 1816
1837 sucked = (plyr->stats.sp * rate) / 100; 1817 sucked = (plyr->stats.sp * rate) / 100;
1838 plyr->stats.sp -= sucked; 1818 plyr->stats.sp -= sucked;
1839 if (QUERY_FLAG (op, FLAG_ALIVE)) 1819 if (op->flag [FLAG_ALIVE])
1840 { 1820 {
1841 /* Player doesn't get full credit */ 1821 /* Player doesn't get full credit */
1842 sucked = (sucked * rate) / 100; 1822 sucked = (sucked * rate) / 100;
1843 op->stats.sp += sucked; 1823 op->stats.sp += sucked;
1844 if (sucked > 0) 1824 if (sucked > 0)
1845 { 1825 {
1846 charge_mana_effect (op, caster_level (caster, spell)); 1826 charge_mana_effect (op, casting_level (caster, spell));
1847 } 1827 }
1848 } 1828 }
1849 return 1; 1829 return 1;
1850 } 1830 }
1851 return 0; 1831 return 0;
… …
1864 object *tmp, *head, *next; 1844 object *tmp, *head, *next;
1865 int mflags; 1845 int mflags;
1866 maptile *m; 1846 maptile *m;
1867 sint16 sx, sy; 1847 sint16 sx, sy;
1868 1848
1869 sx = op->x + freearr_x[dir]; 1849 sx = op->x + DIRX (dir);
1870 sy = op->y + freearr_y[dir]; 1850 sy = op->y + DIRY (dir);
1871 m = op->map; 1851 m = op->map;
1872 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy); 1852 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1873 if (mflags & P_OUT_OF_MAP) 1853 if (mflags & P_OUT_OF_MAP)
1874 return; 1854 return;
1875 1855
… …
1888 1868
1889 /* don't attack our own spells */ 1869 /* don't attack our own spells */
1890 if (tmp->owner && tmp->owner == op->owner) 1870 if (tmp->owner && tmp->owner == op->owner)
1891 continue; 1871 continue;
1892 1872
1893 /* Basically, if the object is magical and not counterspell, 1873 /* Basically, if the object is magical and not counterspell,
1894 * we will more or less remove the object. Don't counterspell 1874 * we will more or less remove the object. Don't counterspell
1895 * monsters either. 1875 * monsters either.
1896 */ 1876 */
1897 1877
1898 if (head->attacktype & AT_MAGIC 1878 if (head->attacktype & AT_MAGIC
1899 && !(head->attacktype & AT_COUNTERSPELL) 1879 && !(head->attacktype & AT_COUNTERSPELL)
1900 && !QUERY_FLAG (head, FLAG_MONSTER) 1880 && !head->flag [FLAG_MONSTER]
1901 && (op->level > head->level)) 1881 && (op->level > head->level))
1902 head->destroy (); 1882 head->destroy ();
1903 else 1883 else
1904 switch (head->type) 1884 switch (head->type)
1905 { 1885 {
1906 case SPELL_EFFECT: 1886 case SPELL_EFFECT:
1907 // XXX: Don't affect floor spelleffects. See also XXX comment 1887 // XXX: Don't affect floor spelleffects. See also XXX comment
1908 // about sanctuary in spell_util.C 1888 // about sanctuary in spell_util.C
1909 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1889 if (tmp->flag [FLAG_IS_FLOOR])
1910 continue; 1890 continue;
1911 1891
1912 if (op->level > head->level) 1892 if (op->level > head->level)
1913 head->destroy (); 1893 head->destroy ();
1914 1894
… …
1927 break; 1907 break;
1928 } 1908 }
1929 } 1909 }
1930} 1910}
1931 1911
1932
1933
1934/* cast_consecrate() - a spell to make an altar your god's */ 1912/* cast_consecrate() - a spell to make an altar your god's */
1935int 1913int
1936cast_consecrate (object *op, object *caster, object *spell) 1914cast_consecrate (object *op, object *caster, object *spell)
1937{ 1915{
1938 char buf[MAX_BUF]; 1916 char buf[MAX_BUF];
1939 1917
1940 object *tmp, *god = find_god (determine_god (op)); 1918 object *tmp, *god = find_god (determine_god (op));
1941 1919
1942 if (!god) 1920 if (!god)
1943 { 1921 {
1944 new_draw_info (NDI_UNIQUE, 0, op, "You can't consecrate anything if you don't worship a god!"); 1922 op->failmsg ("You can't consecrate anything if you don't worship a god!");
1945 return 0; 1923 return 0;
1946 } 1924 }
1947 1925
1948 for (tmp = op->below; tmp; tmp = tmp->below) 1926 for (tmp = op->below; tmp; tmp = tmp->below)
1949 { 1927 {
1950 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1928 if (tmp->flag [FLAG_IS_FLOOR])
1951 break; 1929 break;
1952 if (tmp->type == HOLY_ALTAR) 1930 if (tmp->type == HOLY_ALTAR)
1953 { 1931 {
1954 1932
1955 if (tmp->level > caster_level (caster, spell)) 1933 if (tmp->level > casting_level (caster, spell))
1956 { 1934 {
1957 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name); 1935 op->failmsgf ("You are not powerful enough to reconsecrate the %s", &tmp->name);
1958 return 0; 1936 return 0;
1959 } 1937 }
1960 else 1938 else
1961 { 1939 {
1962 /* If we got here, we are consecrating an altar */ 1940 /* If we got here, we are consecrating an altar */
1963 sprintf (buf, "Altar of %s", &god->name); 1941 sprintf (buf, "Altar of %s", &god->name);
1964 tmp->name = buf; 1942 tmp->name = buf;
1965 tmp->level = caster_level (caster, spell); 1943 tmp->level = casting_level (caster, spell);
1966 tmp->other_arch = god->arch; 1944 tmp->other_arch = god->arch;
1945
1967 if (op->type == PLAYER) 1946 if (op->type == PLAYER)
1968 esrv_update_item (UPD_NAME, op, tmp); 1947 esrv_update_item (UPD_NAME, op, tmp);
1948
1969 new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name); 1949 new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);
1970 return 1; 1950 return 1;
1971 } 1951 }
1972 } 1952 }
1973 } 1953 }
1974 new_draw_info (NDI_UNIQUE, 0, op, "You are not standing over an altar!"); 1954
1955 op->failmsg ("You are not standing over an altar!");
1975 return 0; 1956 return 0;
1976} 1957}
1977 1958
1978/* animate_weapon - 1959/* animate_weapon -
1979 * Generalization of staff_to_snake. Makes a golem out of the caster's weapon. 1960 * Generalization of staff_to_snake. Makes a golem out of the caster's weapon.
1980 * The golem is based on the archetype specified, modified by the caster's level 1961 * The golem is based on the archetype specified, modified by the caster's level
1981 * and the attributes of the weapon. The weapon is inserted in the golem's 1962 * and the attributes of the weapon. The weapon is inserted in the golem's
1982 * inventory so that it falls to the ground when the golem dies. 1963 * inventory so that it falls to the ground when the golem dies.
1983 * This code was very odd - code early on would only let players use the spell, 1964 * This code was very odd - code early on would only let players use the spell,
1984 * yet the code wass full of player checks. I've presumed that the code 1965 * yet the code wass full of player checks. I've presumed that the code
1985 * that only let players use it was correct, and removed all the other 1966 * that only let players use it was correct, and removed all the other
1986 * player checks. MSW 2003-01-06 1967 * player checks. MSW 2003-01-06
1987 */ 1968 */
1988int 1969int
1989animate_weapon (object *op, object *caster, object *spell, int dir) 1970animate_weapon (object *op, object *caster, object *spell, int dir)
1990{ 1971{
1991 object *weapon, *tmp;
1992 char buf[MAX_BUF]; 1972 char buf[MAX_BUF];
1993 int a, i; 1973 int a, i;
1994 sint16 x, y; 1974 sint16 x, y;
1995 maptile *m; 1975 maptile *m;
1996 materialtype_t *mt;
1997 1976
1998 if (!spell->other_arch) 1977 if (!spell->other_arch)
1999 { 1978 {
2000 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 1979 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
2001 LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name); 1980 LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);
… …
2012 return 0; 1991 return 0;
2013 } 1992 }
2014 1993
2015 /* if no direction specified, pick one */ 1994 /* if no direction specified, pick one */
2016 if (!dir) 1995 if (!dir)
2017 dir = find_free_spot (NULL, op->map, op->x, op->y, 1, 9); 1996 dir = find_free_spot (spell->other_arch, op->map, op->x, op->y, 1, 9);
2018 1997
2019 m = op->map; 1998 m = op->map;
2020 x = op->x + freearr_x[dir]; 1999 x = op->x + DIRX (dir);
2021 y = op->y + freearr_y[dir]; 2000 y = op->y + DIRY (dir);
2022 2001
2023 /* if there's no place to put the golem, abort */ 2002 /* if there's no place to put the golem, abort */
2024 if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) || 2003 if (dir < 0 || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP)
2025 ((spell->other_arch->clone.move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->clone.move_type)) 2004 || ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
2026 { 2005 {
2027 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 2006 op->failmsg ("There is something in the way.");
2028 return 0; 2007 return 0;
2029 } 2008 }
2030 2009
2031 /* Use the weapon marked by the player. */ 2010 /* Use the weapon marked by the player. */
2032 weapon = find_marked_object (op); 2011 object *weapon = op->mark ();
2033 2012
2034 if (!weapon) 2013 if (!weapon)
2035 { 2014 {
2036 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!"); 2015 op->failmsg ("You must mark a weapon to use with this spell!");
2037 return 0; 2016 return 0;
2038 } 2017 }
2018
2039 if (spell->race && strcmp (weapon->arch->name, spell->race)) 2019 if (spell->race && weapon->arch->archname != spell->race)
2040 { 2020 {
2041 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon."); 2021 op->failmsg ("The spell fails to transform your weapon.");
2042 return 0; 2022 return 0;
2043 } 2023 }
2024
2044 if (weapon->type != WEAPON) 2025 if (weapon->type != WEAPON)
2045 { 2026 {
2046 new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it."); 2027 op->failmsg ("You need to wield a weapon to animate it.");
2047 return 0; 2028 return 0;
2048 } 2029 }
2049 if (QUERY_FLAG (weapon, FLAG_APPLIED)) 2030
2031 if (weapon->flag [FLAG_APPLIED])
2050 { 2032 {
2051 new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon)); 2033 op->failmsgf ("You need to unequip %s before using it in this spell", query_name (weapon));
2052 return 0; 2034 return 0;
2053 } 2035 }
2054 2036
2055 if (weapon->nrof > 1) 2037 weapon = weapon->split ();
2056 {
2057 tmp = get_split_ob (weapon, 1);
2058 esrv_send_item (op, weapon);
2059 weapon = tmp;
2060 }
2061 2038
2062 /* create the golem object */ 2039 /* create the golem object */
2063 tmp = arch_to_object (spell->other_arch); 2040 object *tmp = spell->other_arch->instance ();
2064 2041
2065 /* if animated by a player, give the player control of the golem */ 2042 /* if animated by a player, give the player control of the golem */
2066 CLEAR_FLAG (tmp, FLAG_MONSTER); 2043 tmp->clr_flag (FLAG_MONSTER);
2067 tmp->stats.exp = 0; 2044 tmp->stats.exp = 0;
2068 add_friendly_object (tmp); 2045 add_friendly_object (tmp);
2069 tmp->type = GOLEM; 2046 tmp->type = GOLEM;
2070 tmp->set_owner (op); 2047 tmp->set_owner (op);
2071 op->contr->golem = tmp; 2048 op->contr->golem = tmp;
2072 set_spell_skill (op, caster, spell, tmp); 2049 set_spell_skill (op, caster, spell, tmp);
2073 2050
2074 /* Give the weapon to the golem now. A bit of a hack to check the 2051 /* Give the weapon to the golem now. A bit of a hack to check the
2075 * removed flag - it should only be set if get_split_object was 2052 * removed flag - it should only be set if weapon->split was
2076 * used above. 2053 * used above.
2077 */ 2054 */
2078 if (!QUERY_FLAG (weapon, FLAG_REMOVED)) 2055 if (!weapon->flag [FLAG_REMOVED])
2079 weapon->remove (); 2056 weapon->remove ();
2080 2057
2081 insert_ob_in_ob (weapon, tmp); 2058 tmp->insert (weapon);
2082 esrv_send_item (op, weapon); 2059
2083 /* To do everything necessary to let a golem use the weapon is a pain, 2060 /* To do everything necessary to let a golem use the weapon is a pain,
2084 * so instead, just set it as equipped (otherwise, we need to update 2061 * so instead, just set it as equipped (otherwise, we need to update
2085 * body_info, skills, etc) 2062 * body_info, skills, etc)
2086 */ 2063 */
2087 SET_FLAG (tmp, FLAG_USE_WEAPON); 2064 tmp->set_flag (FLAG_USE_WEAPON);
2088 SET_FLAG (weapon, FLAG_APPLIED); 2065 weapon->set_flag (FLAG_APPLIED);
2089 tmp->update_stats (); 2066 tmp->update_stats ();
2090 2067
2091 /* There used to be 'odd' code that basically seemed to take the absolute 2068 /* There used to be 'odd' code that basically seemed to take the absolute
2092 * value of the weapon->magic an use that. IMO, that doesn't make sense - 2069 * value of the weapon->magic an use that. IMO, that doesn't make sense -
2093 * if you're using a crappy weapon, it shouldn't be as good. 2070 * if you're using a crappy weapon, it shouldn't be as good.
… …
2113 2090
2114 /* attacktype */ 2091 /* attacktype */
2115 if (!tmp->attacktype) 2092 if (!tmp->attacktype)
2116 tmp->attacktype = AT_PHYSICAL; 2093 tmp->attacktype = AT_PHYSICAL;
2117 2094
2118 mt = NULL;
2119 if (op->materialname != NULL)
2120 mt = name_to_material (op->materialname);
2121 if (mt != NULL)
2122 {
2123 for (i = 0; i < NROFATTACKS; i++) 2095 for (i = 0; i < NROFATTACKS; i++)
2124 tmp->resist[i] = 50 - (mt->save[i] * 5); 2096 tmp->resist[i] = 50 - (op->material->save[i] * 5);
2125 a = mt->save[0]; 2097
2126 } 2098 a = op->material->save[0];
2127 else 2099
2128 {
2129 for (i = 0; i < NROFATTACKS; i++)
2130 tmp->resist[i] = 5;
2131 a = 10;
2132 }
2133 /* Set weapon's immunity */ 2100 /* Set weapon's immunity */
2134 tmp->resist[ATNR_CONFUSION] = 100; 2101 tmp->resist[ATNR_CONFUSION] = 100;
2135 tmp->resist[ATNR_POISON] = 100; 2102 tmp->resist[ATNR_POISON] = 100;
2136 tmp->resist[ATNR_SLOW] = 100; 2103 tmp->resist[ATNR_SLOW] = 100;
2137 tmp->resist[ATNR_PARALYZE] = 100; 2104 tmp->resist[ATNR_PARALYZE] = 100;
… …
2143 2110
2144 /* Improve weapon's armour value according to best save vs. physical of its material */ 2111 /* Improve weapon's armour value according to best save vs. physical of its material */
2145 2112
2146 if (a > 14) 2113 if (a > 14)
2147 a = 14; 2114 a = 14;
2115
2148 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a)); 2116 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.f - (float) tmp->resist[ATNR_PHYSICAL]) / (30.f - 2.f * a));
2149 2117
2150 /* Determine golem's speed */ 2118 /* Determine golem's speed */
2151 tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell))); 2119 tmp->set_speed (min (3.33f, 0.4f + 0.1f * SP_level_range_adjust (caster, spell)));
2152 2120
2153 if (!spell->race) 2121 if (!spell->race)
2154 { 2122 {
2155 sprintf (buf, "animated %s", &weapon->name); 2123 sprintf (buf, "animated %s", &weapon->name);
2156 tmp->name = buf; 2124 tmp->name = buf;
… …
2162 tmp->state = weapon->state; 2130 tmp->state = weapon->state;
2163 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE]; 2131 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2164 } 2132 }
2165 2133
2166 /* make experience increase in proportion to the strength of the summoned creature. */ 2134 /* make experience increase in proportion to the strength of the summoned creature. */
2167 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell)); 2135 tmp->stats.exp *= 1 + (max (spell->stats.maxgrace, spell->stats.sp) / casting_level (caster, spell));
2168 2136
2169 tmp->speed_left = -1; 2137 tmp->speed_left = -1;
2170 tmp->direction = dir; 2138 tmp->direction = dir;
2171 2139
2172 m->insert (tmp, x, y, op); 2140 m->insert (tmp, x, y, op);
… …
2176/* cast_daylight() - changes the map darkness level *lower* */ 2144/* cast_daylight() - changes the map darkness level *lower* */
2177 2145
2178/* cast_change_map_lightlevel: Was cast_daylight/nightfall. 2146/* cast_change_map_lightlevel: Was cast_daylight/nightfall.
2179 * This changes the light level for the entire map. 2147 * This changes the light level for the entire map.
2180 */ 2148 */
2181
2182int 2149int
2183cast_change_map_lightlevel (object *op, object *caster, object *spell) 2150cast_change_map_lightlevel (object *op, object *caster, object *spell)
2184{ 2151{
2185 int success; 2152 int success;
2186 2153
… …
2190 success = op->map->change_map_light (spell->stats.dam); 2157 success = op->map->change_map_light (spell->stats.dam);
2191 2158
2192 if (!success) 2159 if (!success)
2193 { 2160 {
2194 if (spell->stats.dam < 0) 2161 if (spell->stats.dam < 0)
2195 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here."); 2162 op->failmsg ("It can be no brighter here.");
2196 else 2163 else
2197 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here."); 2164 op->failmsg ("It can be no darker here.");
2198 } 2165 }
2166
2199 return success; 2167 return success;
2200} 2168}
2201
2202
2203
2204
2205 2169
2206/* create an aura spell object and put it in the player's inventory. 2170/* create an aura spell object and put it in the player's inventory.
2207 * as usual, op is player, caster is the object casting the spell, 2171 * as usual, op is player, caster is the object casting the spell,
2208 * spell is the spell object itself. 2172 * spell is the spell object itself.
2209 */ 2173 */
… …
2215 2179
2216 new_aura = present_arch_in_ob (spell->other_arch, op); 2180 new_aura = present_arch_in_ob (spell->other_arch, op);
2217 if (new_aura) 2181 if (new_aura)
2218 refresh = 1; 2182 refresh = 1;
2219 else 2183 else
2220 new_aura = arch_to_object (spell->other_arch); 2184 new_aura = spell->other_arch->instance ();
2221 2185
2222 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell); 2186 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2223 2187
2224 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2188 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2225 2189
2226 new_aura->set_owner (op);
2227 set_spell_skill (op, caster, spell, new_aura); 2190 set_spell_skill (op, caster, spell, new_aura);
2228 new_aura->attacktype = spell->attacktype; 2191 new_aura->attacktype = spell->attacktype;
2229 2192
2230 new_aura->level = caster_level (caster, spell); 2193 new_aura->level = casting_level (caster, spell);
2194
2231 if (refresh) 2195 if (refresh)
2232 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 2196 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
2233 else 2197 else
2234 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force."); 2198 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
2199
2235 insert_ob_in_ob (new_aura, op); 2200 insert_ob_in_ob (new_aura, op);
2201 new_aura->set_owner (op);
2202
2236 return 1; 2203 return 1;
2237} 2204}
2238
2239 2205
2240/* move aura function. An aura is a part of someone's inventory, 2206/* move aura function. An aura is a part of someone's inventory,
2241 * which he carries with him, but which acts on the map immediately 2207 * which he carries with him, but which acts on the map immediately
2242 * around him. 2208 * around him.
2243 * Aura parameters: 2209 * Aura parameters:
2244 * duration: duration counter. 2210 * duration: duration counter.
2245 * attacktype: aura's attacktype 2211 * attacktype: aura's attacktype
2246 * other_arch: archetype to drop where we attack 2212 * other_arch: archetype to drop where we attack
2247 */ 2213 */
2248
2249void 2214void
2250move_aura (object *aura) 2215move_aura (object *aura)
2251{ 2216{
2252 int i, mflags;
2253 object *env;
2254 maptile *m;
2255
2256 /* auras belong in inventories */ 2217 /* auras belong in inventories */
2257 env = aura->env; 2218 object *env = aura->env;
2219 object *owner = aura->owner;
2258 2220
2259 /* no matter what we've gotta remove the aura... 2221 /* no matter what we've gotta remove the aura...
2260 * we'll put it back if its time isn't up. 2222 * we'll put it back if its time isn't up.
2261 */ 2223 */
2262 aura->remove (); 2224 aura->remove ();
2263 2225
2264 /* exit if we're out of gas */ 2226 /* exit if we're out of gas */
2265 if (aura->duration-- < 0) 2227 if (aura->duration-- < 0)
… …
2267 aura->destroy (); 2229 aura->destroy ();
2268 return; 2230 return;
2269 } 2231 }
2270 2232
2271 /* auras only exist in inventories */ 2233 /* auras only exist in inventories */
2272 if (env == NULL || env->map == NULL) 2234 if (!env || !env->map)
2273 { 2235 {
2274 aura->destroy (); 2236 aura->destroy ();
2275 return; 2237 return;
2276 } 2238 }
2277 2239
2278 /* we need to jump out of the inventory for a bit 2240 /* we need to jump out of the inventory for a bit
2279 * in order to hit the map conveniently. 2241 * in order to hit the map conveniently.
2280 */ 2242 */
2281 aura->insert_at (env, aura); 2243 aura->insert_at (env, aura);
2282 2244
2283 for (i = 1; i < 9; i++) 2245 for (int i = 1; i < 9; i++)
2284 { 2246 {
2285 sint16 nx, ny; 2247 mapxy pos (env);
2248 pos.move (i);
2286 2249
2287 nx = aura->x + freearr_x[i];
2288 ny = aura->y + freearr_y[i];
2289 mflags = get_map_flags (env->map, &m, nx, ny, &nx, &ny);
2290
2291 /* Consider the movement tyep of the person with the aura as 2250 /* Consider the movement type of the person with the aura as
2292 * movement type of the aura. Eg, if the player is flying, the aura 2251 * movement type of the aura. Eg, if the player is flying, the aura
2293 * is flying also, if player is walking, it is on the ground, etc. 2252 * is flying also, if player is walking, it is on the ground, etc.
2294 */ 2253 */
2295 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny)))) 2254 if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2296 { 2255 {
2297 hit_map (aura, i, aura->attacktype, 0); 2256 hit_map (aura, i, aura->attacktype, 0);
2298 2257
2299 if (aura->other_arch) 2258 if (aura->other_arch)
2300 m->insert (arch_to_object (aura->other_arch), nx, ny, aura); 2259 pos.insert (aura->other_arch->instance (), aura);
2301 } 2260 }
2302 } 2261 }
2303 2262
2304 /* put the aura back in the player's inventory */ 2263 /* put the aura back in the player's inventory */
2305 aura->remove (); 2264 env->insert (aura);
2306 insert_ob_in_ob (aura, env); 2265 aura->set_owner (owner);
2307} 2266}
2308 2267
2309/* moves the peacemaker spell. 2268/* moves the peacemaker spell.
2310 * op is the piece object. 2269 * op is the piece object.
2311 */ 2270 */
2312
2313void 2271void
2314move_peacemaker (object *op) 2272move_peacemaker (object *op)
2315{ 2273{
2316 object *tmp; 2274 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
2317
2318 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
2319 { 2275 {
2320 int atk_lev, def_lev; 2276 int atk_lev, def_lev;
2321 object *victim = tmp; 2277 object *victim = tmp->head_ ();
2322 2278
2323 if (tmp->head) 2279 if (!victim->flag [FLAG_MONSTER])
2324 victim = tmp->head;
2325 if (!QUERY_FLAG (victim, FLAG_MONSTER))
2326 continue; 2280 continue;
2327 if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE)) 2281
2282 if (victim->flag [FLAG_UNAGGRESSIVE])
2328 continue; 2283 continue;
2284
2329 if (victim->stats.exp == 0) 2285 if (victim->stats.exp == 0)
2330 continue; 2286 continue;
2331 2287
2332 def_lev = MAX (1, victim->level); 2288 def_lev = max (1, victim->level);
2333 atk_lev = MAX (1, op->level); 2289 atk_lev = max (1, op->level);
2334 2290
2335 if (rndm (0, atk_lev - 1) > def_lev) 2291 if (rndm (0, atk_lev - 1) > def_lev)
2336 { 2292 {
2337 /* make this sucker peaceful. */ 2293 /* make this sucker peaceful. */
2338 2294
2295 INVOKE_OBJECT (KILL, victim, ARG_OBJECT (op));
2339 change_exp (op->owner, victim->stats.exp, op->skill, 0); 2296 change_exp (op->owner, victim->stats.exp, op->skill, 0);
2340 victim->stats.exp = 0; 2297 victim->stats.exp = 0;
2341#if 0 2298#if 0
2342 /* No idea why these were all set to zero - if something 2299 /* No idea why these were all set to zero - if something
2343 * makes this creature agressive, he should still do damage. 2300 * makes this creature agressive, he should still do damage.
… …
2346 victim->stats.sp = 0; 2303 victim->stats.sp = 0;
2347 victim->stats.grace = 0; 2304 victim->stats.grace = 0;
2348 victim->stats.Pow = 0; 2305 victim->stats.Pow = 0;
2349#endif 2306#endif
2350 victim->attack_movement = RANDO2; 2307 victim->attack_movement = RANDO2;
2351 SET_FLAG (victim, FLAG_UNAGGRESSIVE); 2308 victim->set_flag (FLAG_UNAGGRESSIVE);
2352 SET_FLAG (victim, FLAG_RUN_AWAY); 2309 victim->set_flag (FLAG_RUN_AWAY);
2353 SET_FLAG (victim, FLAG_RANDOM_MOVE); 2310 victim->set_flag (FLAG_RANDOM_MOVE);
2354 CLEAR_FLAG (victim, FLAG_MONSTER); 2311 victim->clr_flag (FLAG_MONSTER);
2312
2355 if (victim->name) 2313 if (victim->name)
2356 {
2357 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name); 2314 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);
2358 } 2315 }
2359 }
2360 } 2316 }
2361} 2317}
2362
2363 2318
2364/* This writes a rune that contains the appropriate message. 2319/* This writes a rune that contains the appropriate message.
2365 * There really isn't any adjustments we make. 2320 * There really isn't any adjustments we make.
2366 */ 2321 */
2367
2368int 2322int
2369write_mark (object *op, object *spell, const char *msg) 2323write_mark (object *op, object *spell, const char *msg)
2370{ 2324{
2371 char rune[HUGE_BUF];
2372 object *tmp;
2373
2374 if (!msg || msg[0] == 0) 2325 if (!msg || msg[0] == 0)
2375 { 2326 {
2376 new_draw_info (NDI_UNIQUE, 0, op, "Write what?"); 2327 op->failmsg ("Write what?");
2377 return 0; 2328 return 0;
2378 } 2329 }
2379 2330
2380 if (strcasestr_local (msg, "endmsg")) 2331 if (!msg_is_safe (msg))
2381 { 2332 {
2382 new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?"); 2333 op->failmsg ("Trying to cheat are we? H<@-signs are not allowed in marking runes.>");
2383 LOG (llevInfo, "write_rune: player %s tried to write bogus rune %s\n", &op->name, msg); 2334 LOG (llevInfo, "write_mark: player %s tried to write bogus rune %s\n", &op->name, msg);
2384 return 0; 2335 return 0;
2385 } 2336 }
2337
2386 if (!spell->other_arch) 2338 if (!spell->other_arch)
2387 return 0; 2339 return 0;
2388 tmp = arch_to_object (spell->other_arch);
2389 2340
2390 snprintf (rune, sizeof (rune), "%s\n", msg); 2341 object *tmp = spell->other_arch->instance ();
2391 2342
2392 tmp->race = op->name; /*Save the owner of the rune */ 2343 tmp->race = op->name; /*Save the owner of the rune */
2393 tmp->msg = rune; 2344 tmp->msg = msg;
2394 2345
2395 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR); 2346 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
2347
2396 return 1; 2348 return 1;
2397} 2349}
2350

Diff Legend

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