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.4 by root, Tue Aug 29 07:34:00 2006 UTC vs.
Revision 1.143 by root, Mon Nov 12 03:48:34 2012 UTC

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

Diff Legend

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