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

Comparing deliantra/server/server/spell_util.C (file contents):
Revision 1.7 by root, Tue Aug 29 07:34:00 2006 UTC vs.
Revision 1.27 by root, Mon Dec 25 11:25:50 2006 UTC

1/*
2 * static char *rcsid_spell_util_c =
3 * "$Id: spell_util.C,v 1.7 2006/08/29 07:34:00 root Exp $";
4 */
5
6
7/* 1/*
8 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
9 3
10 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2001 Mark Wedel & Crossfire Development Team
11 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
22 16
23 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 20
27 The authors can be reached via e-mail at crossfire-devel@real-time.com 21 The authors can be reached via e-mail at <crossfire@schmorp.de>
28*/ 22*/
29 23
30 24
31#include <global.h> 25#include <global.h>
32#include <spells.h> 26#include <spells.h>
33#include <object.h> 27#include <object.h>
34#include <errno.h> 28#include <errno.h>
35#ifndef __CEXTRACT__ 29#ifndef __CEXTRACT__
36#include <sproto.h> 30# include <sproto.h>
37#endif 31#endif
38#include <sounds.h> 32#include <sounds.h>
39 33
40extern char *spell_mapping[]; 34extern char *spell_mapping[];
41 35
42/* This returns a random spell from 'ob'. If skill is set, then 36/* This returns a random spell from 'ob'. If skill is set, then
43 * the spell must be of this skill, it can be NULL in which case all 37 * the spell must be of this skill, it can be NULL in which case all
44 * matching spells are used. 38 * matching spells are used.
45 */ 39 */
40object *
46object *find_random_spell_in_ob(object *ob, const char *skill) 41find_random_spell_in_ob (object *ob, const char *skill)
47{ 42{
48 int k=0,s; 43 int k = 0, s;
49 object *tmp; 44 object *tmp;
50 45
51 for (tmp=ob->inv; tmp; tmp=tmp->below) 46 for (tmp = ob->inv; tmp; tmp = tmp->below)
52 if (tmp->type == SPELL && (!skill || tmp->skill == skill)) k++; 47 if (tmp->type == SPELL && (!skill || tmp->skill == skill))
48 k++;
53 49
54 /* No spells, no need to progess further */ 50 /* No spells, no need to progess further */
55 if (!k) return NULL; 51 if (!k)
56
57 s = RANDOM() % k;
58
59 for (tmp=ob->inv; tmp; tmp=tmp->below)
60 if (tmp->type == SPELL && (!skill || tmp->skill == skill)) {
61 if (!s) return tmp;
62 else s--;
63 }
64 /* Should never get here, but just in case */
65 return NULL; 52 return NULL;
53
54 s = RANDOM () % k;
55
56 for (tmp = ob->inv; tmp; tmp = tmp->below)
57 if (tmp->type == SPELL && (!skill || tmp->skill == skill))
58 {
59 if (!s)
60 return tmp;
61 else
62 s--;
63 }
64 /* Should never get here, but just in case */
65 return NULL;
66} 66}
67 67
68/* Relatively simple function that gets used a lot. 68/* Relatively simple function that gets used a lot.
69 * Basically, it sets up the skill pointer for the spell being 69 * Basically, it sets up the skill pointer for the spell being
70 * cast. If op is really casting the spell, then the skill 70 * cast. If op is really casting the spell, then the skill
71 * is whatever skill the spell requires. 71 * is whatever skill the spell requires.
72 * if instead caster (rod, horn, wand, etc) is casting the skill, 72 * if instead caster (rod, horn, wand, etc) is casting the skill,
73 * then they get exp for the skill that you need to use for 73 * then they get exp for the skill that you need to use for
74 * that object (use magic device). 74 * that object (use magic device).
75 */ 75 */
76void
76void set_spell_skill(object *op, object *caster, object *spob, object *dest) 77set_spell_skill (object *op, object *caster, object *spob, object *dest)
77{ 78{
78 if (dest->skill) FREE_AND_CLEAR_STR(dest->skill);
79 if (caster == op && spob->skill) 79 if (caster == op && spob->skill)
80 dest->skill = add_refcount(spob->skill); 80 dest->skill = spob->skill;
81 else if (caster->skill) 81 else
82 dest->skill = add_refcount(caster->skill); 82 dest->skill = caster->skill;
83} 83}
84 84
85/* init_spells: This should really be called check_spells, as that 85/* init_spells: This should really be called check_spells, as that
86 * is what it does. It goes through the spells looking for any 86 * is what it does. It goes through the spells looking for any
87 * obvious errors. This was most useful in debugging when re-doing 87 * obvious errors. This was most useful in debugging when re-doing
88 * all the spells to catch simple errors. To use it all the time 88 * all the spells to catch simple errors. To use it all the time
89 * will result in it spitting out messages that aren't really errors. 89 * will result in it spitting out messages that aren't really errors.
90 */ 90 */
91void
91void init_spells(void) { 92init_spells (void)
93{
92#ifdef SPELL_DEBUG 94#ifdef SPELL_DEBUG
93 static int init_spells_done = 0; 95 static int init_spells_done = 0;
94 int i; 96 int i;
95 archetype *at; 97 archetype *at;
96 98
97 if (init_spells_done) 99 if (init_spells_done)
98 return; 100 return;
99 LOG(llevDebug, "Checking spells...\n"); 101 LOG (llevDebug, "Checking spells...\n");
100 102
101 for (at=first_archetype; at; at=at->next) { 103 for (at = first_archetype; at; at = at->next)
104 {
102 if (at->clone.type == SPELL) { 105 if (at->clone.type == SPELL)
106 {
103 if (at->clone.skill) { 107 if (at->clone.skill)
104 for (i=1; i<NUM_SKILLS; i++) 108 {
109 for (i = 1; i < NUM_SKILLS; i++)
105 if (!strcmp(skill_names[i], at->clone.skill)) break; 110 if (!strcmp (skill_names[i], at->clone.skill))
106 if (i==NUM_SKILLS) { 111 break;
112 if (i == NUM_SKILLS)
113 {
107 LOG(llevError,"Spell %s has improper associated skill %s\n", at->name, at->clone.skill); 114 LOG (llevError, "Spell %s has improper associated skill %s\n", at->name, at->clone.skill);
108 } 115 }
109 } 116 }
110 /* other_arch is already checked for in the loader */ 117 /* other_arch is already checked for in the loader */
111 } 118 }
112 } 119 }
113 120
114 i=0; 121 i = 0;
115 while (spell_mapping[i]) { 122 while (spell_mapping[i])
123 {
116 if (!find_archetype(spell_mapping[i])) { 124 if (!archetype::find (spell_mapping[i]))
125 {
117 LOG(llevError,"Unable to find spell mapping %s (%i)\n", spell_mapping[i], i); 126 LOG (llevError, "Unable to find spell mapping %s (%i)\n", spell_mapping[i], i);
118 } 127 }
119 i++; 128 i++;
120 } 129 }
121 LOG(llevDebug, "Checking spells completed.\n"); 130 LOG (llevDebug, "Checking spells completed.\n");
122#endif 131#endif
123} 132}
124 133
125/* Dumps all the spells - now also dumps skill associated with the spell. 134/* Dumps all the spells - now also dumps skill associated with the spell.
126 * not sure what this would be used for, as the data seems pretty 135 * not sure what this would be used for, as the data seems pretty
127 * minimal, but easy enough to keep around. 136 * minimal, but easy enough to keep around.
128 */ 137 */
138void
129void dump_spells(void) 139dump_spells (void)
130{ 140{
131 archetype *at; 141 archetype *at;
132 142
133 for (at=first_archetype; at; at=at->next) { 143 for (at = first_archetype; at; at = at->next)
144 {
134 if (at->clone.type == SPELL) { 145 if (at->clone.type == SPELL)
146 {
135 fprintf(stderr, "%s:%s:%s:%s:%d\n", at->clone.name?at->clone.name:"null", 147 fprintf (stderr, "%s:%s:%s:%s:%d\n", &at->clone.name,
136 at->name, at->clone.other_arch?at->clone.other_arch->name:"null", 148 &at->name, at->clone.other_arch ? &at->clone.other_arch->name : "<nil>", &at->clone.skill, at->clone.level);
137 at->clone.skill?at->clone.skill:"null", at->clone.level); 149 }
138 }
139 } 150 }
140} 151}
141 152
142/* pretty basic function - basically just takes 153/* pretty basic function - basically just takes
143 * an object, sets the x,y, and calls insert_ob_in_map 154 * an object, sets the x,y, and calls insert_ob_in_map
144 */ 155 */
145 156
157void
146void spell_effect (object *spob, int x, int y, mapstruct *map, 158spell_effect (object *spob, int x, int y, maptile *map, object *originator)
147 object *originator)
148{ 159{
149 160
150 if (spob->other_arch != NULL) { 161 if (spob->other_arch != NULL)
162 {
151 object *effect = arch_to_object(spob->other_arch); 163 object *effect = arch_to_object (spob->other_arch);
152 164
153 effect->x = x; 165 effect->x = x;
154 effect->y = y; 166 effect->y = y;
155 167
156 insert_ob_in_map(effect, map, originator,0); 168 insert_ob_in_map (effect, map, originator, 0);
157 } 169 }
158} 170}
159 171
160/* 172/*
161 * This function takes a caster and spell and presents the 173 * This function takes a caster and spell and presents the
… …
165 * 177 *
166 * caster is person casting hte spell. 178 * caster is person casting hte spell.
167 * spell is the spell object. 179 * spell is the spell object.
168 * Returns modified level. 180 * Returns modified level.
169 */ 181 */
182int
170int min_casting_level(object *caster, object *spell) 183min_casting_level (object *caster, object *spell)
171{ 184{
172 int new_level; 185 int new_level;
173 186
174 if (caster->path_denied & spell->path_attuned) { 187 if (caster->path_denied & spell->path_attuned)
175 /* This case is not a bug, just the fact that this function is
176 * usually called BEFORE checking for path_deny. -AV
177 */
178#if 0
179 LOG (llevError, "BUG: path_level_mod (arch %s, name %s): casting denied "
180 "spell\n", caster->arch->name, caster->name);
181#endif
182 return 1; 188 return 1;
183 } 189
184 new_level = spell->level 190 new_level = spell->level
185 + ((caster->path_repelled & spell->path_attuned) ? +2 : 0) 191 + ((caster->path_repelled & spell->path_attuned) ? +2 : 0) + ((caster->path_attuned & spell->path_attuned) ? -2 : 0);
186 + ((caster->path_attuned & spell->path_attuned) ? -2 : 0); 192
187 return (new_level < 1) ? 1 : new_level; 193 return (new_level < 1) ? 1 : new_level;
188} 194}
189 195
190 196
191/* This function returns the effective level the spell 197/* This function returns the effective level the spell
192 * is being cast at. 198 * is being cast at.
193 * Note that I changed the repelled/attuned bonus to 2 from 5. 199 * Note that I changed the repelled/attuned bonus to 2 from 5.
194 * This is because the new code compares casting_level against 200 * This is because the new code compares casting_level against
195 * min_caster_level, so the difference is effectively 4 201 * min_caster_level, so the difference is effectively 4
196 */ 202 */
197 203
204int
198int caster_level(object *caster, object *spell) 205caster_level (object *caster, object *spell)
199{ 206{
200 int level = caster->level; 207 int level = caster->level;
201 208
202 /* If this is a player, try to find the matching skill */ 209 /* If this is a player, try to find the matching skill */
203 if (caster->type == PLAYER && spell->skill) { 210 if (caster->type == PLAYER && spell->skill)
204 int i;
205
206 for (i=0; i < NUM_SKILLS; i++) 211 for (int i = 0; i < NUM_SKILLS; i++)
207 if (caster->contr->last_skill_ob[i] && 212 if (caster->contr->last_skill_ob[i] && caster->contr->last_skill_ob[i]->skill == spell->skill)
208 caster->contr->last_skill_ob[i]->skill == spell->skill) { 213 {
209 level = caster->contr->last_skill_ob[i]->level; 214 level = caster->contr->last_skill_ob[i]->level;
210 break; 215 break;
211 } 216 }
212 }
213 217
214 /* if a rod is fired by a player, take the use_magic_item skill in consideration. */ 218 /* if a rod is fired by a player, take the use_magic_item skill in consideration. */
215 if (caster->type == ROD && caster->env && caster->env->type == PLAYER) 219 if (caster->type == ROD && caster->env && caster->env->type == PLAYER)
216 { 220 {
217 object *skill = find_skill_by_number (caster->env, SK_USE_MAGIC_ITEM); 221 object *skill = find_skill_by_number (caster->env, SK_USE_MAGIC_ITEM);
218 int sk_level = skill ? skill->level : 1; 222 int sk_level = skill ? skill->level : 1;
223
219 level = MIN (level, sk_level + level / 10 + 1); 224 level = MIN (level, sk_level + level / 10 + 1);
220 }
221 225 }
226
222 /* Got valid caster level. Now adjust for attunement */ 227 /* Got valid caster level. Now adjust for attunement */
223 level += ((caster->path_repelled & spell->path_attuned) ? -2 : 0) 228 level += ((caster->path_repelled & spell->path_attuned) ? -2 : 0) + ((caster->path_attuned & spell->path_attuned) ? 2 : 0);
224 + ((caster->path_attuned & spell->path_attuned) ? 2 : 0);
225 229
226 /* Always make this at least 1. If this is zero, we get divide by zero 230 /* Always make this at least 1. If this is zero, we get divide by zero
227 * errors in various places. 231 * errors in various places.
228 */ 232 */
229 if (level < 1) level = 1; 233 if (level < 1)
234 level = 1;
235
230 return level; 236 return level;
231} 237}
232 238
233/* The following function scales the spellpoint cost of 239/* The following function scales the spellpoint cost of
234 * a spell by it's increased effectiveness. Some of the 240 * a spell by it's increased effectiveness. Some of the
235 * lower level spells become incredibly vicious at high 241 * lower level spells become incredibly vicious at high
… …
240 * spell is the spell object. 246 * spell is the spell object.
241 * Note that it is now possible for a spell to cost both grace and 247 * Note that it is now possible for a spell to cost both grace and
242 * mana. In that case, we return which ever value is higher. 248 * mana. In that case, we return which ever value is higher.
243 */ 249 */
244 250
251sint16
245sint16 SP_level_spellpoint_cost(object *caster, object *spell, int flags) 252SP_level_spellpoint_cost (object *caster, object *spell, int flags)
246{ 253{
247 int sp, grace, level = caster_level(caster, spell); 254 int sp, grace, level = caster_level (caster, spell);
248 255
249 if (settings.spellpoint_level_depend == TRUE) { 256 if (settings.spellpoint_level_depend == TRUE)
257 {
250 if (spell->stats.sp && spell->stats.maxsp) { 258 if (spell->stats.sp && spell->stats.maxsp)
251 sp= (int) (spell->stats.sp * 259 {
252 (1.0 + MAX(0, 260 sp = (int) (spell->stats.sp * (1.0 + MAX (0, (float) (level - spell->level) / (float) spell->stats.maxsp)));
253 (float)(level-spell->level)/ (float)spell->stats.maxsp))); 261 }
254 } 262 else
255 else sp = spell->stats.sp; 263 sp = spell->stats.sp;
256 264
257 sp *= (int) PATH_SP_MULT(caster,spell); 265 sp *= (int) PATH_SP_MULT (caster, spell);
258 if (!sp && spell->stats.sp) sp=1; 266 if (!sp && spell->stats.sp)
267 sp = 1;
259 268
260 if (spell->stats.grace && spell->stats.maxgrace) { 269 if (spell->stats.grace && spell->stats.maxgrace)
261 grace= (int) (spell->stats.grace * 270 {
262 (1.0 + MAX(0, 271 grace = (int) (spell->stats.grace * (1.0 + MAX (0, (float) (level - spell->level) / (float) spell->stats.maxgrace)));
263 (float)(level-spell->level)/ (float)spell->stats.maxgrace))); 272 }
264 } 273 else
265 else grace = spell->stats.grace; 274 grace = spell->stats.grace;
266 275
267 grace *= (int) PATH_SP_MULT(caster,spell); 276 grace *= (int) PATH_SP_MULT (caster, spell);
268 if (spell->stats.grace && !grace) grace=1; 277 if (spell->stats.grace && !grace)
269 } else { 278 grace = 1;
279 }
280 else
281 {
270 sp = (int) (spell->stats.sp * PATH_SP_MULT(caster,spell)); 282 sp = (int) (spell->stats.sp * PATH_SP_MULT (caster, spell));
271 if (spell->stats.sp && !sp) sp=1; 283 if (spell->stats.sp && !sp)
284 sp = 1;
272 grace = (int) (spell->stats.grace * PATH_SP_MULT(caster,spell)); 285 grace = (int) (spell->stats.grace * PATH_SP_MULT (caster, spell));
273 if (spell->stats.grace && !grace) grace=1; 286 if (spell->stats.grace && !grace)
287 grace = 1;
274 } 288 }
275 if (flags == SPELL_HIGHEST) 289 if (flags == SPELL_HIGHEST)
276 return MAX(sp, grace); 290 return MAX (sp, grace);
277 else if (flags == SPELL_GRACE) 291 else if (flags == SPELL_GRACE)
278 return grace; 292 return grace;
279 else if (flags == SPELL_MANA) 293 else if (flags == SPELL_MANA)
280 return sp; 294 return sp;
281 else { 295 else
296 {
282 LOG(llevError, "SP_level_spellpoint_cost: Unknown flags passed: %d\n", flags); 297 LOG (llevError, "SP_level_spellpoint_cost: Unknown flags passed: %d\n", flags);
283 return 0; 298 return 0;
284 } 299 }
285} 300}
286 301
287 302
288/* SP_level_dam_adjust: Returns adjusted damage based on the caster. 303/* SP_level_dam_adjust: Returns adjusted damage based on the caster.
289 * spob is the spell we are adjusting. 304 * spob is the spell we are adjusting.
290 */ 305 */
306int
291int SP_level_dam_adjust(object *caster, object *spob) 307SP_level_dam_adjust (object *caster, object *spob)
292{ 308{
293 int level = caster_level (caster, spob); 309 int level = caster_level (caster, spob);
294 int adj = level - min_casting_level(caster, spob); 310 int adj = level - min_casting_level (caster, spob);
295 311
296 if(adj < 0) adj=0; 312 if (adj < 0)
313 adj = 0;
297 if (spob->dam_modifier) 314 if (spob->dam_modifier)
298 adj/=spob->dam_modifier; 315 adj /= spob->dam_modifier;
299 else adj=0; 316 else
317 adj = 0;
300 return adj; 318 return adj;
301} 319}
302 320
303/* Adjust the strength of the spell based on level. 321/* Adjust the strength of the spell based on level.
304 * This is basically the same as SP_level_dam_adjust above, 322 * This is basically the same as SP_level_dam_adjust above,
305 * but instead looks at the level_modifier value. 323 * but instead looks at the level_modifier value.
306 */ 324 */
325int
307int SP_level_duration_adjust(object *caster, object *spob) 326SP_level_duration_adjust (object *caster, object *spob)
308{ 327{
309 int level = caster_level (caster, spob); 328 int level = caster_level (caster, spob);
310 int adj = level - min_casting_level(caster, spob); 329 int adj = level - min_casting_level (caster, spob);
311 330
312 if(adj < 0) adj=0; 331 if (adj < 0)
332 adj = 0;
313 if(spob->duration_modifier) 333 if (spob->duration_modifier)
314 adj/=spob->duration_modifier; 334 adj /= spob->duration_modifier;
315 else adj=0; 335 else
336 adj = 0;
316 337
317 return adj; 338 return adj;
318} 339}
319 340
320/* Adjust the strength of the spell based on level. 341/* Adjust the strength of the spell based on level.
321 * This is basically the same as SP_level_dam_adjust above, 342 * This is basically the same as SP_level_dam_adjust above,
322 * but instead looks at the level_modifier value. 343 * but instead looks at the level_modifier value.
323 */ 344 */
345int
324int SP_level_range_adjust(object *caster, object *spob) 346SP_level_range_adjust (object *caster, object *spob)
325{ 347{
326 int level = caster_level (caster, spob); 348 int level = caster_level (caster, spob);
327 int adj = level - min_casting_level(caster, spob); 349 int adj = level - min_casting_level (caster, spob);
328 350
329 if(adj < 0) adj=0; 351 if (adj < 0)
352 adj = 0;
330 if(spob->range_modifier) 353 if (spob->range_modifier)
331 adj/=spob->range_modifier; 354 adj /= spob->range_modifier;
332 else adj=0; 355 else
356 adj = 0;
333 357
334 return adj; 358 return adj;
335} 359}
336 360
337/* Checks to see if player knows the spell. If the name is the same 361/* Checks to see if player knows the spell. If the name is the same
338 * as an existing spell, we presume they know it. 362 * as an existing spell, we presume they know it.
339 * returns 1 if they know the spell, 0 if they don't. 363 * returns 1 if they know the spell, 0 if they don't.
340 */ 364 */
365object *
341object *check_spell_known (object *op, const char *name) 366check_spell_known (object *op, const char *name)
342{ 367{
343 object *spop; 368 object *spop;
344 369
345 for (spop=op->inv; spop; spop=spop->below) 370 for (spop = op->inv; spop; spop = spop->below)
346 if (spop->type == SPELL && !strcmp(spop->name, name)) return spop; 371 if (spop->type == SPELL && !strcmp (spop->name, name))
372 return spop;
347 373
348 return NULL; 374 return NULL;
349} 375}
350 376
351 377
352/* 378/*
353 * Look at object 'op' and see if they know the spell 379 * Look at object 'op' and see if they know the spell
… …
356 * returns the matching spell object, or NULL. 382 * returns the matching spell object, or NULL.
357 * If we match multiple spells but don't get an 383 * If we match multiple spells but don't get an
358 * exact match, we also return NULL. 384 * exact match, we also return NULL.
359 */ 385 */
360 386
387object *
361object *lookup_spell_by_name(object *op,const char *spname) { 388lookup_spell_by_name (object *op, const char *spname)
389{
362 object *spob1=NULL, *spob2=NULL, *spob; 390 object *spob1 = NULL, *spob2 = NULL, *spob;
363 int nummatch=0; 391 int nummatch = 0;
364 392
365 if(spname==NULL) return NULL; 393 if (spname == NULL)
366
367 /* Try to find the spell. We store the results in spob1
368 * and spob2 - spob1 is only taking the length of
369 * the past spname, spob2 uses the length of the spell name.
370 */
371 for (spob = op->inv; spob; spob=spob->below) {
372 if (spob->type == SPELL) {
373 if (!strncmp(spob->name, spname, strlen(spname))) {
374 nummatch++;
375 spob1 = spob;
376 } else if (!strncmp(spob->name, spname, strlen(spob->name))) {
377 /* if spells have ambiguous names, it makes matching
378 * really difficult. (eg, fire and fireball would
379 * fall into this category). It shouldn't be hard to
380 * make sure spell names don't overlap in that fashion.
381 */
382 if (spob2)
383 LOG(llevError,"Found multiple spells with overlapping base names: %s, %s\n",
384 spob2->name, spob->name);
385 spob2 = spob;
386 }
387 }
388 }
389 /* if we have best match, return it. Otherwise, if we have one match
390 * on the loser match, return that, otehrwise null
391 */
392 if (spob2) return spob2;
393 if (spob1 && nummatch == 1) return spob1;
394 return NULL; 394 return NULL;
395
396 /* Try to find the spell. We store the results in spob1
397 * and spob2 - spob1 is only taking the length of
398 * the past spname, spob2 uses the length of the spell name.
399 */
400 for (spob = op->inv; spob; spob = spob->below)
401 {
402 if (spob->type == SPELL)
403 {
404 if (!strncmp (spob->name, spname, strlen (spname)))
405 {
406 nummatch++;
407 spob1 = spob;
408 }
409 else if (!strncmp (spob->name, spname, strlen (spob->name)))
410 {
411 /* if spells have ambiguous names, it makes matching
412 * really difficult. (eg, fire and fireball would
413 * fall into this category). It shouldn't be hard to
414 * make sure spell names don't overlap in that fashion.
415 */
416 if (spob2)
417 LOG (llevError, "Found multiple spells with overlapping base names: %s, %s\n", &spob2->name, &spob->name);
418 spob2 = spob;
419 }
420 }
421 }
422 /* if we have best match, return it. Otherwise, if we have one match
423 * on the loser match, return that, otehrwise null
424 */
425 if (spob2)
426 return spob2;
427 if (spob1 && nummatch == 1)
428 return spob1;
429 return NULL;
395} 430}
396 431
397/* reflwall - decides weither the (spell-)object sp_op will 432/* reflwall - decides weither the (spell-)object sp_op will
398 * be reflected from the given mapsquare. Returns 1 if true. 433 * be reflected from the given mapsquare. Returns 1 if true.
399 * (Note that for living creatures there is a small chance that 434 * (Note that for living creatures there is a small chance that
400 * reflect_spell fails.) 435 * reflect_spell fails.)
401 * Caller should be sure it passes us valid map coordinates 436 * Caller should be sure it passes us valid map coordinates
402 * eg, updated for tiled maps. 437 * eg, updated for tiled maps.
403 */ 438 */
439int
404int reflwall(mapstruct *m,int x,int y, object *sp_op) { 440reflwall (maptile *m, int x, int y, object *sp_op)
441{
405 object *op; 442 object *op;
406 443
407 if(OUT_OF_REAL_MAP(m,x,y)) return 0; 444 if (OUT_OF_REAL_MAP (m, x, y))
408 for(op=get_map_ob(m,x,y);op!=NULL;op=op->above)
409 if(QUERY_FLAG(op, FLAG_REFL_SPELL) && (!QUERY_FLAG(op, FLAG_ALIVE) ||
410 sp_op->type==LIGHTNING || (rndm(0, 99)) < 90-(sp_op->level/10)))
411 return 1;
412
413 return 0; 445 return 0;
446 for (op = GET_MAP_OB (m, x, y); op != NULL; op = op->above)
447 if (QUERY_FLAG (op, FLAG_REFL_SPELL)
448 && (!QUERY_FLAG (op, FLAG_ALIVE)
449 || (rndm (0, 99)) < 90 - (sp_op->level / 10)))
450 return 1;
451
452 return 0;
414} 453}
415 454
416/* cast_create_object: creates object new_op in direction dir 455/* cast_create_object: creates object new_op in direction dir
417 * or if that is blocked, beneath the player (op). 456 * or if that is blocked, beneath the player (op).
418 * we pass 'caster', but don't use it for anything. 457 * we pass 'caster', but don't use it for anything.
419 * This is really just a simple wrapper function . 458 * This is really just a simple wrapper function .
420 * returns the direction that the object was actually placed 459 * returns the direction that the object was actually placed
421 * in. 460 * in.
422 */ 461 */
462int
423int cast_create_obj(object *op,object *caster,object *new_op, int dir) 463cast_create_obj (object *op, object *caster, object *new_op, int dir)
424{ 464{
425 mapstruct *m; 465 maptile *m;
426 sint16 sx, sy; 466 sint16 sx, sy;
427 467
428 if(dir && 468 if (dir &&
429 ((get_map_flags(op->map, &m, op->x+freearr_x[dir],op->y+freearr_y[dir], &sx, &sy) & P_OUT_OF_MAP) || 469 ((get_map_flags (op->map, &m, op->x + freearr_x[dir], op->y + freearr_y[dir], &sx, &sy) & P_OUT_OF_MAP) ||
430 OB_TYPE_MOVE_BLOCK(op, GET_MAP_MOVE_BLOCK(m, sx, sy)))) { 470 OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))))
471 {
431 new_draw_info(NDI_UNIQUE, 0,op,"Something is in the way."); 472 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
432 new_draw_info(NDI_UNIQUE, 0,op,"You cast it at your feet."); 473 new_draw_info (NDI_UNIQUE, 0, op, "You cast it at your feet.");
433 dir = 0; 474 dir = 0;
434 } 475 }
435 new_op->x=op->x+freearr_x[dir]; 476 new_op->x = op->x + freearr_x[dir];
436 new_op->y=op->y+freearr_y[dir]; 477 new_op->y = op->y + freearr_y[dir];
437 if (dir == 0) 478 if (dir == 0)
438 insert_ob_in_map(new_op,op->map,op,INS_BELOW_ORIGINATOR); 479 insert_ob_in_map (new_op, op->map, op, INS_BELOW_ORIGINATOR);
439 else 480 else
440 insert_ob_in_map(new_op,op->map,op,0); 481 insert_ob_in_map (new_op, op->map, op, 0);
441 return dir; 482 return dir;
442} 483}
443 484
444/* Returns true if it is ok to put spell *op on the space/may provided. 485/* Returns true if it is ok to put spell *op on the space/may provided.
445 * immune_stop is basically the attacktype of the spell (why 486 * immune_stop is basically the attacktype of the spell (why
446 * passed as a different value, not sure of). If immune_stop 487 * passed as a different value, not sure of). If immune_stop
… …
448 * on the space, the object doesn't get placed. if immune stop 489 * on the space, the object doesn't get placed. if immune stop
449 * does not have AT_MAGIC, then counterwalls do not effect the spell. 490 * does not have AT_MAGIC, then counterwalls do not effect the spell.
450 * 491 *
451 */ 492 */
452 493
494int
453int ok_to_put_more(mapstruct *m,sint16 x,sint16 y,object *op,int immune_stop) { 495ok_to_put_more (maptile *m, sint16 x, sint16 y, object *op, int immune_stop)
496{
454 object *tmp; 497 object *tmp;
455 int mflags; 498 int mflags;
456 mapstruct *mp; 499 maptile *mp;
457 500
458 mp = m; 501 mp = m;
459 mflags = get_map_flags(m, &mp, x, y, &x, &y); 502 mflags = get_map_flags (m, &mp, x, y, &x, &y);
460 503
461 if (mflags & P_OUT_OF_MAP) return 0; 504 if (mflags & P_OUT_OF_MAP)
462
463 if (OB_TYPE_MOVE_BLOCK(op, GET_MAP_MOVE_BLOCK(mp, x, y))) return 0;
464
465 for(tmp=get_map_ob(mp,x,y);tmp!=NULL;tmp=tmp->above) {
466 /* If there is a counterspell on the space, and this
467 * object is using magic, don't progress. I believe we could
468 * leave this out and let in progress, and other areas of the code
469 * will then remove it, but that would seem to to use more
470 * resources, and may not work as well if a player is standing
471 * on top of a counterwall spell (may hit the player before being
472 * removed.) On the other hand, it may be more dramatic for the
473 * spell to actually hit the counterwall and be sucked up.
474 */
475 if ((tmp->attacktype & AT_COUNTERSPELL) &&
476 (tmp->type != PLAYER) && !QUERY_FLAG(tmp,FLAG_MONSTER) &&
477 (tmp->type != WEAPON) && (tmp->type != BOW) &&
478 (tmp->type != ARROW) && (tmp->type != GOLEM) &&
479 (immune_stop & AT_MAGIC)) return 0;
480
481 /* This is to prevent 'out of control' spells. Basically, this
482 * limits one spell effect per space per spell. This is definately
483 * needed for performance reasons, and just for playability I believe.
484 * there are no such things as multispaced spells right now, so
485 * we don't need to worry about the head.
486 */
487 if ((tmp->stats.maxhp == op->stats.maxhp) && (tmp->type == op->type) &&
488 (tmp->subtype == op->subtype))
489 return 0; 505 return 0;
490 506
507 if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (mp, x, y)))
508 return 0;
509
510 for (tmp = GET_MAP_OB (mp, x, y); tmp != NULL; tmp = tmp->above)
511 {
512 /* If there is a counterspell on the space, and this
513 * object is using magic, don't progress. I believe we could
514 * leave this out and let in progress, and other areas of the code
515 * will then remove it, but that would seem to to use more
516 * resources, and may not work as well if a player is standing
517 * on top of a counterwall spell (may hit the player before being
518 * removed.) On the other hand, it may be more dramatic for the
519 * spell to actually hit the counterwall and be sucked up.
520 */
521 if ((tmp->attacktype & AT_COUNTERSPELL) &&
522 (tmp->type != PLAYER) && !QUERY_FLAG (tmp, FLAG_MONSTER) &&
523 (tmp->type != WEAPON) && (tmp->type != BOW) && (tmp->type != ARROW) && (tmp->type != GOLEM) && (immune_stop & AT_MAGIC))
524 return 0;
525
526 /* This is to prevent 'out of control' spells. Basically, this
527 * limits one spell effect per space per spell. This is definately
528 * needed for performance reasons, and just for playability I believe.
529 * there are no such things as multispaced spells right now, so
530 * we don't need to worry about the head.
531 */
532 if ((tmp->stats.maxhp == op->stats.maxhp) && (tmp->type == op->type) && (tmp->subtype == op->subtype))
533 return 0;
534
491 /* 535 /*
492 * Combine similar spell effects into one spell effect. Needed for 536 * Combine similar spell effects into one spell effect. Needed for
493 * performance reasons with meteor swarm and the like, but also for 537 * performance reasons with meteor swarm and the like, but also for
494 * playability reasons. 538 * playability reasons.
495 */ 539 */
496 if (tmp->arch == op->arch 540 if (tmp->arch == op->arch
497 && tmp->type == op->type 541 && tmp->type == op->type
498 && tmp->subtype == op->subtype 542 && tmp->subtype == op->subtype
499 && tmp->owner == op->owner 543 && tmp->owner == op->owner && ((tmp->subtype == SP_EXPLOSION) || (tmp->subtype == SP_CONE && tmp->stats.sp == op->stats.sp)))
500 && ((tmp->subtype == SP_EXPLOSION)
501 || (tmp->subtype == SP_CONE && tmp->stats.sp == op->stats.sp))
502 ) { 544 {
503 tmp->stats.dam = MAX (tmp->stats.dam, op->stats.dam); 545 tmp->stats.dam = MAX (tmp->stats.dam, op->stats.dam);
504 tmp->range = MAX (tmp->range, op->range); 546 tmp->range = MAX (tmp->range, op->range);
505 tmp->duration = MAX (tmp->duration, op->duration); 547 tmp->duration = MAX (tmp->duration, op->duration);
506 return 0; 548 return 0;
507 } 549 }
508 550
509 /* Perhaps we should also put checks in for no magic and unholy 551 /* Perhaps we should also put checks in for no magic and unholy
510 * ground to prevent it from moving along? 552 * ground to prevent it from moving along?
511 */ 553 */
512 } 554 }
513 /* If it passes the above tests, it must be OK */ 555 /* If it passes the above tests, it must be OK */
514 return 1; 556 return 1;
515} 557}
516 558
517/* fire_arch_from_position: fires an archetype. 559/* fire_arch_from_position: fires an archetype.
518 * op: person firing the object. 560 * op: person firing the object.
519 * caster: object casting the spell. 561 * caster: object casting the spell.
… …
522 * dir: direction to fire in. 564 * dir: direction to fire in.
523 * spell: spell that is being fired. It uses other_arch for the archetype 565 * spell: spell that is being fired. It uses other_arch for the archetype
524 * to fire. 566 * to fire.
525 * returns 0 on failure, 1 on success. 567 * returns 0 on failure, 1 on success.
526 */ 568 */
527 569
570int
528int fire_arch_from_position (object *op, object *caster, sint16 x, sint16 y, 571fire_arch_from_position (object *op, object *caster, sint16 x, sint16 y, int dir, object *spell)
529 int dir, object *spell)
530{ 572{
531 object *tmp; 573 object *tmp;
532 int mflags; 574 int mflags;
533 mapstruct *m; 575 maptile *m;
534 576
535 if(spell->other_arch==NULL) 577 if (spell->other_arch == NULL)
536 return 0; 578 return 0;
537 579
538 m = op->map; 580 m = op->map;
539 mflags = get_map_flags(m, &m, x, y, &x, &y); 581 mflags = get_map_flags (m, &m, x, y, &x, &y);
540 if (mflags & P_OUT_OF_MAP) { 582 if (mflags & P_OUT_OF_MAP)
541 return 0;
542 } 583 {
584 return 0;
585 }
543 586
544 tmp=arch_to_object(spell->other_arch); 587 tmp = arch_to_object (spell->other_arch);
545 588
546 if(tmp==NULL) 589 if (tmp == NULL)
547 return 0; 590 return 0;
548 591
549 if (OB_TYPE_MOVE_BLOCK(tmp, GET_MAP_MOVE_BLOCK(m, x, y))) { 592 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (m, x, y)))
593 {
550 new_draw_info(NDI_UNIQUE, 0, op, "You can't cast the spell on top of a wall!\n"); 594 new_draw_info (NDI_UNIQUE, 0, op, "You can't cast the spell on top of a wall!\n");
551 free_object(tmp); 595 tmp->destroy ();
552 return 0; 596 return 0;
553 } 597 }
554 598
555
556
557 tmp->stats.dam=spell->stats.dam+SP_level_dam_adjust(caster,spell); 599 tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
558 tmp->duration=spell->duration+SP_level_duration_adjust(caster,spell); 600 tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
559 /* code in time.c uses food for some things, duration for others */ 601 /* code in time.c uses food for some things, duration for others */
560 tmp->stats.food = tmp->duration; 602 tmp->stats.food = tmp->duration;
561 tmp->range=spell->range+SP_level_range_adjust(caster,spell); 603 tmp->range = spell->range + SP_level_range_adjust (caster, spell);
562 tmp->attacktype = spell->attacktype; 604 tmp->attacktype = spell->attacktype;
563 tmp->x=x; 605 tmp->x = x;
564 tmp->y=y; 606 tmp->y = y;
565 tmp->direction=dir; 607 tmp->direction = dir;
566 if (get_owner (op) != NULL) 608 if (op->owner != NULL)
567 copy_owner (tmp, op); 609 tmp->set_owner (op);
568 else 610 else
569 set_owner (tmp, op); 611 tmp->set_owner (op);
570 tmp->level = caster_level (caster, spell); 612 tmp->level = caster_level (caster, spell);
571 set_spell_skill(op, caster, spell, tmp); 613 set_spell_skill (op, caster, spell, tmp);
572 614
573 /* needed for AT_HOLYWORD,AT_GODPOWER stuff */ 615 /* needed for AT_HOLYWORD,AT_GODPOWER stuff */
574 if(tmp->attacktype&AT_HOLYWORD || tmp->attacktype&AT_GODPOWER) { 616 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
575 if(!tailor_god_spell(tmp,op)) return 0;
576 } 617 {
618 if (!tailor_god_spell (tmp, op))
619 return 0;
620 }
577 if(QUERY_FLAG(tmp, FLAG_IS_TURNABLE)) 621 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
578 SET_ANIMATION(tmp, dir); 622 SET_ANIMATION (tmp, dir);
579 623
580 if ((tmp = insert_ob_in_map (tmp, m, op,0)) == NULL) 624 if ((tmp = insert_ob_in_map (tmp, m, op, 0)) == NULL)
581 return 1;
582
583 move_spell_effect(tmp);
584
585 return 1; 625 return 1;
626
627 move_spell_effect (tmp);
628
629 return 1;
586} 630}
587 631
588 632
589 633
590/***************************************************************************** 634/*****************************************************************************
591 * 635 *
592 * Code related to rods - perhaps better located in another file? 636 * Code related to rods - perhaps better located in another file?
593 * 637 *
594 ****************************************************************************/ 638 ****************************************************************************/
595 639
640void
596void regenerate_rod(object *rod) { 641regenerate_rod (object *rod)
642{
597 if (rod->stats.hp < rod->stats.maxhp) { 643 if (rod->stats.hp < rod->stats.maxhp)
644 {
598 rod->stats.hp+= 1 + rod->stats.maxhp/10; 645 rod->stats.hp += 1 + rod->stats.maxhp / 10;
599 646
600 if (rod->stats.hp > rod->stats.maxhp) 647 if (rod->stats.hp > rod->stats.maxhp)
601 rod->stats.hp = rod->stats.maxhp; 648 rod->stats.hp = rod->stats.maxhp;
602 } 649 }
603} 650}
604 651
605 652
653void
606void drain_rod_charge(object *rod) { 654drain_rod_charge (object *rod)
655{
607 rod->stats.hp -= SP_level_spellpoint_cost(rod, rod->inv, SPELL_HIGHEST); 656 rod->stats.hp -= SP_level_spellpoint_cost (rod, rod->inv, SPELL_HIGHEST);
608} 657}
609 658
610 659
611 660
612 661
… …
615 * op is what is looking for the target (which can be a player), 664 * op is what is looking for the target (which can be a player),
616 * dir is the direction we are looking in. Return object found, or 665 * dir is the direction we are looking in. Return object found, or
617 * NULL if no good object. 666 * NULL if no good object.
618 */ 667 */
619 668
669object *
620object *find_target_for_friendly_spell(object *op,int dir) { 670find_target_for_friendly_spell (object *op, int dir)
671{
621 object *tmp; 672 object *tmp;
622 mapstruct *m; 673 maptile *m;
623 sint16 x, y; 674 sint16 x, y;
624 int mflags; 675 int mflags;
625 676
626 /* I don't really get this block - if op isn't a player or rune, 677 /* I don't really get this block - if op isn't a player or rune,
627 * we then make the owner of this object the target. 678 * we then make the owner of this object the target.
628 * The owner could very well be no where near op. 679 * The owner could very well be no where near op.
629 */ 680 */
630 if(op->type!=PLAYER && op->type!=RUNE) { 681 if (op->type != PLAYER && op->type != RUNE)
631 tmp=get_owner(op); 682 {
683 tmp = op->owner;
632 /* If the owner does not exist, or is not a monster, than apply the spell 684 /* If the owner does not exist, or is not a monster, than apply the spell
633 * to the caster. 685 * to the caster.
634 */ 686 */
635 if(!tmp || !QUERY_FLAG(tmp,FLAG_MONSTER)) tmp=op; 687 if (!tmp || !QUERY_FLAG (tmp, FLAG_MONSTER))
688 tmp = op;
689 }
690 else
636 } 691 {
637 else {
638 m = op->map; 692 m = op->map;
639 x = op->x+freearr_x[dir]; 693 x = op->x + freearr_x[dir];
640 y = op->y+freearr_y[dir]; 694 y = op->y + freearr_y[dir];
641 695
642 mflags = get_map_flags(m, &m, x, y, &x, &y); 696 mflags = get_map_flags (m, &m, x, y, &x, &y);
643 697
644 if (mflags & P_OUT_OF_MAP) 698 if (mflags & P_OUT_OF_MAP)
645 tmp=NULL; 699 tmp = 0;
646 else { 700 else
647 for(tmp=get_map_ob(m, x, y); tmp!=NULL; tmp=tmp->above) 701 tmp = m->at (x, y).player ();
648 if(tmp->type==PLAYER)
649 break;
650 }
651 } 702 }
703
652 /* didn't find a player there, look in current square for a player */ 704 /* didn't find a player there, look in current square for a player */
653 if(tmp==NULL) 705 if (!tmp)
654 for(tmp=get_map_ob(op->map,op->x,op->y);tmp!=NULL;tmp=tmp->above) 706 tmp = op->ms ().player ();
655 {
656 if(tmp->type==PLAYER)
657 break;
658 }
659 707
660 return tmp; 708 return tmp;
661} 709}
662 710
663 711
664 712
665/* raytrace: 713/* raytrace:
… …
672 * It returns the direction toward the first/closest live object if it finds 720 * It returns the direction toward the first/closest live object if it finds
673 * any, otherwise -1. 721 * any, otherwise -1.
674 * note that exclude can be NULL, in which case all bets are off. 722 * note that exclude can be NULL, in which case all bets are off.
675 */ 723 */
676 724
725int
677int spell_find_dir(mapstruct *m, int x, int y, object *exclude) { 726spell_find_dir (maptile *m, int x, int y, object *exclude)
727{
678 int i,max=SIZEOFFREE; 728 int i, max = SIZEOFFREE;
679 sint16 nx,ny; 729 sint16 nx, ny;
680 int owner_type=0, mflags; 730 int owner_type = 0, mflags;
681 object *tmp; 731 object *tmp;
682 mapstruct *mp; 732 maptile *mp;
683 733
684 if (exclude && exclude->head) 734 if (exclude && exclude->head)
685 exclude = exclude->head; 735 exclude = exclude->head;
686 if (exclude && exclude->type) 736 if (exclude && exclude->type)
687 owner_type = exclude->type; 737 owner_type = exclude->type;
688 738
689 for(i=rndm(1, 8);i<max;i++) { 739 for (i = rndm (1, 8); i < max; i++)
740 {
690 nx = x + freearr_x[i]; 741 nx = x + freearr_x[i];
691 ny = y + freearr_y[i]; 742 ny = y + freearr_y[i];
692 mp = m; 743 mp = m;
693 mflags = get_map_flags(m, &mp, nx, ny, &nx, &ny); 744 mflags = get_map_flags (m, &mp, nx, ny, &nx, &ny);
694 if (mflags & (P_OUT_OF_MAP | P_BLOCKSVIEW)) continue; 745 if (mflags & (P_OUT_OF_MAP | P_BLOCKSVIEW))
746 continue;
695 747
696 tmp=get_map_ob(mp,nx,ny); 748 tmp = GET_MAP_OB (mp, nx, ny);
697 749
698 while(tmp!=NULL && (((owner_type==PLAYER && 750 while (tmp != NULL && (((owner_type == PLAYER &&
699 !QUERY_FLAG(tmp,FLAG_MONSTER) && !QUERY_FLAG(tmp,FLAG_GENERATOR)) || 751 !QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_GENERATOR)) ||
700 (owner_type!=PLAYER && tmp->type!=PLAYER)) || 752 (owner_type != PLAYER && tmp->type != PLAYER)) || (tmp == exclude || (tmp->head && tmp->head == exclude))))
701 (tmp == exclude || (tmp->head && tmp->head == exclude))))
702 tmp=tmp->above; 753 tmp = tmp->above;
703 754
704 if(tmp!=NULL && can_see_monsterP(m,x,y,i)) 755 if (tmp != NULL && can_see_monsterP (m, x, y, i))
705 return freedir[i]; 756 return freedir[i];
706 } 757 }
707 return -1; /* flag for "keep going the way you were" */ 758 return -1; /* flag for "keep going the way you were" */
708} 759}
709 760
710 761
711 762
712/* put_a_monster: puts a monster named monstername near by 763/* put_a_monster: puts a monster named monstername near by
713 * op. This creates the treasures for the monsters, and 764 * op. This creates the treasures for the monsters, and
714 * also deals with multipart monsters properly. 765 * also deals with multipart monsters properly.
715 */ 766 */
716 767
768void
717void put_a_monster(object *op,const char *monstername) { 769put_a_monster (object *op, const char *monstername)
770{
718 object *tmp,*head=NULL,*prev=NULL; 771 object *tmp, *head = NULL, *prev = NULL;
719 archetype *at; 772 archetype *at;
720 int dir; 773 int dir;
721 774
722 /* Handle cases where we are passed a bogus mosntername */ 775 /* Handle cases where we are passed a bogus mosntername */
723 776
724 if((at=find_archetype(monstername))==NULL) return; 777 if ((at = archetype::find (monstername)) == NULL)
778 return;
725 779
726 /* find a free square nearby 780 /* find a free square nearby
727 * first we check the closest square for free squares 781 * first we check the closest square for free squares
728 */ 782 */
729 783
730 dir=find_first_free_spot(&at->clone,op->map,op->x,op->y); 784 dir = find_first_free_spot (&at->clone, op->map, op->x, op->y);
731 if(dir!=-1) { 785 if (dir != -1)
786 {
732 /* This is basically grabbed for generate monster. Fixed 971225 to 787 /* This is basically grabbed for generate monster. Fixed 971225 to
733 * insert multipart monsters properly 788 * insert multipart monsters properly
734 */ 789 */
735 while (at!=NULL) { 790 while (at != NULL)
791 {
736 tmp=arch_to_object(at); 792 tmp = arch_to_object (at);
737 tmp->x=op->x+freearr_x[dir]+at->clone.x; 793 tmp->x = op->x + freearr_x[dir] + at->clone.x;
738 tmp->y=op->y+freearr_y[dir]+at->clone.y; 794 tmp->y = op->y + freearr_y[dir] + at->clone.y;
739 tmp->map = op->map; 795 tmp->map = op->map;
740 if (head) { 796 if (head)
741 tmp->head=head; 797 {
742 prev->more=tmp; 798 tmp->head = head;
743 } 799 prev->more = tmp;
744 if (!head) head=tmp; 800 }
745 prev=tmp; 801 if (!head)
802 head = tmp;
803 prev = tmp;
746 at=at->more; 804 at = at->more;
747 } 805 }
748 806
749 if (head->randomitems) 807 if (head->randomitems)
750 create_treasure(head->randomitems, head, GT_INVISIBLE, op->map->difficulty,0); 808 create_treasure (head->randomitems, head, GT_INVISIBLE, op->map->difficulty, 0);
751 809
752 insert_ob_in_map(head,op->map,op,0); 810 insert_ob_in_map (head, op->map, op, 0);
753 811
754 /* thought it'd be cool to insert a burnout, too.*/ 812 /* thought it'd be cool to insert a burnout, too. */
755 tmp=get_archetype("burnout"); 813 tmp = get_archetype ("burnout");
756 tmp->map = op->map; 814 tmp->map = op->map;
757 tmp->x=op->x+freearr_x[dir]; 815 tmp->x = op->x + freearr_x[dir];
758 tmp->y=op->y+freearr_y[dir]; 816 tmp->y = op->y + freearr_y[dir];
759 insert_ob_in_map(tmp,op->map,op,0); 817 insert_ob_in_map (tmp, op->map, op, 0);
760 } 818 }
761} 819}
762 820
763/* peterm: function which summons hostile monsters and 821/* peterm: function which summons hostile monsters and
764 * places them in nearby squares. 822 * places them in nearby squares.
… …
772 * use to call this, but best I can tell, that spell/ability was 830 * use to call this, but best I can tell, that spell/ability was
773 * never used. This is however used by various failures on the 831 * never used. This is however used by various failures on the
774 * players part (alchemy, reincarnation, etc) 832 * players part (alchemy, reincarnation, etc)
775 */ 833 */
776 834
835int
777int summon_hostile_monsters(object *op,int n,const char *monstername){ 836summon_hostile_monsters (object *op, int n, const char *monstername)
837{
778 int i; 838 int i;
839
779 for(i=0;i<n;i++) 840 for (i = 0; i < n; i++)
780 put_a_monster(op,monstername); 841 put_a_monster (op, monstername);
781 842
782 return n; 843 return n;
783} 844}
784 845
785 846
786/* Some local definitions for shuffle-attack */ 847/* Some local definitions for shuffle-attack */
787 struct attacktype_shuffle { 848struct attacktype_shuffle
849{
788 int attacktype; 850 int attacktype;
789 int face; 851 int face;
790 } ATTACKS[22] = { 852} ATTACKS[22] =
853{
854 {
791 {AT_PHYSICAL,0}, 855 AT_PHYSICAL, 0},
856 {
792 {AT_PHYSICAL,0}, /*face = explosion*/ 857 AT_PHYSICAL, 0}, /*face = explosion */
858 {
793 {AT_PHYSICAL,0}, 859 AT_PHYSICAL, 0},
860 {
794 {AT_MAGIC,1}, 861 AT_MAGIC, 1},
862 {
795 {AT_MAGIC,1}, /* face = last-burnout */ 863 AT_MAGIC, 1}, /* face = last-burnout */
864 {
796 {AT_MAGIC,1}, 865 AT_MAGIC, 1},
866 {
797 {AT_FIRE,2}, 867 AT_FIRE, 2},
868 {
798 {AT_FIRE,2}, /* face = fire.... */ 869 AT_FIRE, 2}, /* face = fire.... */
870 {
799 {AT_FIRE,2}, 871 AT_FIRE, 2},
872 {
800 {AT_ELECTRICITY,3}, 873 AT_ELECTRICITY, 3},
874 {
801 {AT_ELECTRICITY,3}, /* ball_lightning */ 875 AT_ELECTRICITY, 3}, /* ball_lightning */
876 {
802 {AT_ELECTRICITY,3}, 877 AT_ELECTRICITY, 3},
803 {AT_COLD,4}, 878 {
804 {AT_COLD,4}, /* face=icestorm*/
805 {AT_COLD,4}, 879 AT_COLD, 4},
880 {
881 AT_COLD, 4}, /* face=icestorm */
882 {
883 AT_COLD, 4},
884 {
806 {AT_CONFUSION,5}, 885 AT_CONFUSION, 5},
886 {
807 {AT_POISON,7}, 887 AT_POISON, 7},
888 {
808 {AT_POISON,7}, /* face = acid sphere. generator */ 889 AT_POISON, 7}, /* face = acid sphere. generator */
890 {
809 {AT_POISON,7}, /* poisoncloud face */ 891 AT_POISON, 7}, /* poisoncloud face */
892 {
810 {AT_SLOW,8}, 893 AT_SLOW, 8},
894 {
811 {AT_PARALYZE,9}, 895 AT_PARALYZE, 9},
896 {
812 {AT_FEAR,10} }; 897AT_FEAR, 10}};
813 898
814 899
815 900
816/* shuffle_attack: peterm 901/* shuffle_attack: peterm
817 * This routine shuffles the attack of op to one of the 902 * This routine shuffles the attack of op to one of the
… …
827 * would be nice. 912 * would be nice.
828 * I also fixed a bug here in that attacktype was |= - 913 * I also fixed a bug here in that attacktype was |= -
829 * to me, that would be that it would quickly get all 914 * to me, that would be that it would quickly get all
830 * attacktypes, which probably wasn't the intent. MSW 2003-06-03 915 * attacktypes, which probably wasn't the intent. MSW 2003-06-03
831 */ 916 */
917void
832void shuffle_attack(object *op,int change_face) 918shuffle_attack (object *op, int change_face)
833{ 919{
834 int i; 920 int i;
921
835 i=rndm(0, 21); 922 i = rndm (0, 21);
836 923
837 op->attacktype=ATTACKS[i].attacktype|AT_MAGIC; 924 op->attacktype = ATTACKS[i].attacktype | AT_MAGIC;
838 925
839 if(change_face) { 926 if (change_face)
927 {
840 SET_ANIMATION(op, ATTACKS[i].face); 928 SET_ANIMATION (op, ATTACKS[i].face);
841 } 929 }
842} 930}
843 931
844 932
845/* prayer_failure: This is called when a player fails 933/* prayer_failure: This is called when a player fails
… …
847 * op is the player. 935 * op is the player.
848 * failure is basically how much grace they had. 936 * failure is basically how much grace they had.
849 * power is how much grace the spell would normally take to cast. 937 * power is how much grace the spell would normally take to cast.
850 */ 938 */
851 939
940void
852void prayer_failure(object *op, int failure,int power) 941prayer_failure (object *op, int failure, int power)
853{ 942{
854 const char *godname; 943 const char *godname;
855 object *tmp; 944 object *tmp;
856 945
857 if(!strcmp((godname=determine_god(op)),"none")) godname="Your spirit"; 946 if (!strcmp ((godname = determine_god (op)), "none"))
947 godname = "Your spirit";
858 948
859 if(failure<= -20 && failure > -40) /* wonder */ 949 if (failure <= -20 && failure > -40) /* wonder */
860 { 950 {
861 new_draw_info_format(NDI_UNIQUE, 0,op,"%s gives a sign to renew your faith.",godname); 951 new_draw_info_format (NDI_UNIQUE, 0, op, "%s gives a sign to renew your faith.", godname);
862 tmp = get_archetype(SPELL_WONDER); 952 tmp = get_archetype (SPELL_WONDER);
863 cast_cone(op,op,0,tmp); 953 cast_cone (op, op, 0, tmp);
864 free_object(tmp); 954 tmp->destroy ();
865 } 955 }
866 956
867 else if (failure <= -40 && failure > -60) /* confusion */ 957 else if (failure <= -40 && failure > -60) /* confusion */
868 { 958 {
869 new_draw_info(NDI_UNIQUE, 0,op,"Your diety touches your mind!"); 959 new_draw_info (NDI_UNIQUE, 0, op, "Your diety touches your mind!");
870 confuse_player(op,op,99); 960 confuse_player (op, op, 99);
871 } 961 }
872 else if (failure <= -60 && failure> -150) /* paralysis */ 962 else if (failure <= -60 && failure > -150) /* paralysis */
873 { 963 {
874 new_draw_info_format(NDI_UNIQUE, 0,op,"%s requires you to pray NOW.",godname); 964 new_draw_info_format (NDI_UNIQUE, 0, op, "%s requires you to pray NOW.", godname);
875 new_draw_info(NDI_UNIQUE, 0,op,"You comply, ignoring all else."); 965 new_draw_info (NDI_UNIQUE, 0, op, "You comply, ignoring all else.");
876 paralyze_player(op,op,99); 966 paralyze_player (op, op, 99);
877 } 967 }
878 else if (failure <= -150) /* blast the immediate area */ 968 else if (failure <= -150) /* blast the immediate area */
879 { 969 {
880 tmp = get_archetype(GOD_POWER); 970 tmp = get_archetype (GOD_POWER);
881 new_draw_info_format(NDI_UNIQUE, 0,op,"%s smites you!",godname); 971 new_draw_info_format (NDI_UNIQUE, 0, op, "%s smites you!", godname);
882 cast_magic_storm(op,tmp, power); 972 cast_magic_storm (op, tmp, power);
883 } 973 }
884} 974}
885 975
886/* 976/*
887 * spell_failure() handles the various effects for differing degrees 977 * spell_failure() handles the various effects for differing degrees
… …
890 * failure is a random value of how badly you failed. 980 * failure is a random value of how badly you failed.
891 * power is how many spellpoints you'd normally need for the spell. 981 * power is how many spellpoints you'd normally need for the spell.
892 * skill is the skill you'd need to cast the spell. 982 * skill is the skill you'd need to cast the spell.
893 */ 983 */
894 984
985void
895void spell_failure(object *op, int failure,int power, object *skill) 986spell_failure (object *op, int failure, int power, object *skill)
896{ 987{
897 object *tmp; 988 object *tmp;
898 989
899 if (settings.spell_failure_effects == FALSE) 990 if (settings.spell_failure_effects == FALSE)
900 return; 991 return;
901 992
902 if (failure<=-20 && failure > -40) /* wonder */ 993 if (failure <= -20 && failure > -40) /* wonder */
903 { 994 {
904 new_draw_info(NDI_UNIQUE, 0,op,"Your spell causes an unexpected effect."); 995 new_draw_info (NDI_UNIQUE, 0, op, "Your spell causes an unexpected effect.");
905 tmp = get_archetype(SPELL_WONDER); 996 tmp = get_archetype (SPELL_WONDER);
906 cast_cone(op,op,0,tmp); 997 cast_cone (op, op, 0, tmp);
907 free_object(tmp); 998 tmp->destroy ();
908 } 999 }
909 1000
910 else if (failure <= -40 && failure > -60) /* confusion */ 1001 else if (failure <= -40 && failure > -60) /* confusion */
911 { 1002 {
912 new_draw_info(NDI_UNIQUE, 0,op,"Your magic recoils on you, making you confused!"); 1003 new_draw_info (NDI_UNIQUE, 0, op, "Your magic recoils on you, making you confused!");
913 confuse_player(op,op,99); 1004 confuse_player (op, op, 99);
914 } 1005 }
915 else if (failure <= -60 && failure> -80) /* paralysis */ 1006 else if (failure <= -60 && failure > -80) /* paralysis */
916 { 1007 {
917 new_draw_info(NDI_UNIQUE, 0,op,"Your magic stuns you!"); 1008 new_draw_info (NDI_UNIQUE, 0, op, "Your magic stuns you!");
918 paralyze_player(op,op,99); 1009 paralyze_player (op, op, 99);
919 } 1010 }
920 else if (failure <= -80) /* blast the immediate area */ 1011 else if (failure <= -80) /* blast the immediate area */
921 { 1012 {
922 object *tmp; 1013 object *tmp;
1014
923 /* Safety check to make sure we don't get any mana storms in scorn */ 1015 /* Safety check to make sure we don't get any mana storms in scorn */
924 if (get_map_flags(op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC) { 1016 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC)
925 new_draw_info(NDI_UNIQUE, 0, op, "The magic warps and you are turned inside out!");
926 hit_player(op,9998,op,AT_INTERNAL,1);
927
928 } else {
929 new_draw_info(NDI_UNIQUE, 0,op,"You lose control of the mana! The uncontrolled magic blasts you!");
930 tmp=get_archetype(LOOSE_MANA);
931 tmp->level=skill->level;
932 tmp->x=op->x;
933 tmp->y=op->y;
934
935 /* increase the area of destruction a little for more powerful spells */
936 tmp->range+=isqrt(power);
937
938 if (power>25) tmp->stats.dam = 25 + isqrt(power);
939 else tmp->stats.dam=power; /* nasty recoils! */
940
941 tmp->stats.maxhp=tmp->count;
942 insert_ob_in_map(tmp,op->map,NULL,0);
943 }
944 }
945}
946
947int cast_party_spell(object *op, object *caster,int dir,object *spell_ob, char *stringarg)
948 {
949 int success;
950 player *pl;
951 object *spell;
952
953 if ( !spell_ob->other_arch )
954 { 1017 {
955 LOG( llevError, "cast_party_spell: empty other arch\n" ); 1018 new_draw_info (NDI_UNIQUE, 0, op, "The magic warps and you are turned inside out!");
956 return 0; 1019 hit_player (op, 9998, op, AT_INTERNAL, 1);
957 }
958 spell = arch_to_object( spell_ob->other_arch );
959 1020
960 /* Always cast spell on caster */ 1021 }
961 success = cast_spell( op, caster, dir, spell, stringarg ); 1022 else
962
963 if ( caster->contr->party == NULL )
964 { 1023 {
965 remove_ob( spell ); 1024 new_draw_info (NDI_UNIQUE, 0, op, "You lose control of the mana! The uncontrolled magic blasts you!");
1025 tmp = get_archetype (LOOSE_MANA);
1026 tmp->level = skill->level;
1027 tmp->x = op->x;
1028 tmp->y = op->y;
1029
1030 /* increase the area of destruction a little for more powerful spells */
1031 tmp->range += isqrt (power);
1032
1033 if (power > 25)
1034 tmp->stats.dam = 25 + isqrt (power);
1035 else
1036 tmp->stats.dam = power; /* nasty recoils! */
1037
1038 tmp->stats.maxhp = tmp->count;
1039 insert_ob_in_map (tmp, op->map, NULL, 0);
1040 }
1041 }
1042}
1043
1044int
1045cast_party_spell (object *op, object *caster, int dir, object *spell_ob, char *stringarg)
1046{
1047 int success;
1048 player *pl;
1049 object *spell;
1050
1051 if (!spell_ob->other_arch)
1052 {
1053 LOG (llevError, "cast_party_spell: empty other arch\n");
1054 return 0;
1055 }
1056 spell = arch_to_object (spell_ob->other_arch);
1057
1058 /* Always cast spell on caster */
1059 success = cast_spell (op, caster, dir, spell, stringarg);
1060
1061 if (caster->contr->party == NULL)
1062 {
1063 spell->remove ();
966 return success; 1064 return success;
967 } 1065 }
968 for( pl=first_player; pl!=NULL; pl=pl->next ) 1066 for_all_players (pl)
969 if( ( pl->ob->contr->party == caster->contr->party ) && ( on_same_map( pl->ob, caster ) ) ) 1067 if ((pl->ob->contr->party == caster->contr->party) && (on_same_map (pl->ob, caster)))
970 { 1068 {
971 cast_spell( pl->ob, caster, pl->ob->facing, spell, stringarg ); 1069 cast_spell (pl->ob, caster, pl->ob->facing, spell, stringarg);
972 } 1070 }
973 remove_ob( spell ); 1071 spell->remove ();
974 return success; 1072 return success;
975 } 1073}
976 1074
977/* This is where the main dispatch when someone casts a spell. 1075/* This is where the main dispatch when someone casts a spell.
978 * 1076 *
979 * op is the creature that is owner of the object that is casting the spell - 1077 * op is the creature that is owner of the object that is casting the spell -
980 * eg, the player or monster. 1078 * eg, the player or monster.
… …
1000 * if it is a player casting the spell (op->type == PLAYER, op == caster), 1098 * if it is a player casting the spell (op->type == PLAYER, op == caster),
1001 * this function will decrease the mana/grace appropriately. For other 1099 * this function will decrease the mana/grace appropriately. For other
1002 * objects, the caller should do what it considers appropriate. 1100 * objects, the caller should do what it considers appropriate.
1003 */ 1101 */
1004 1102
1103int
1005int cast_spell(object *op, object *caster,int dir,object *spell_ob, char *stringarg) { 1104cast_spell (object *op, object *caster, int dir, object *spell_ob, char *stringarg)
1006 1105{
1007 const char *godname; 1106 const char *godname;
1008 int success=0,mflags, cast_level=0, old_shoottype; 1107 int success = 0, mflags, cast_level = 0, old_shoottype;
1009 object *skill=NULL; 1108 object *skill = NULL;
1010 1109
1011 old_shoottype = op->contr ? op->contr->shoottype : 0; 1110 old_shoottype = op->contr ? op->contr->shoottype : 0;
1012 1111
1013 if (!spell_ob) { 1112 if (!spell_ob)
1113 {
1014 LOG(llevError,"cast_spell: null spell object passed\n"); 1114 LOG (llevError, "cast_spell: null spell object passed\n");
1015 return 0; 1115 return 0;
1016 } 1116 }
1017 if(!strcmp((godname=determine_god(op)),"none")) godname="A random spirit";
1018 1117
1118 if (!strcmp ((godname = determine_god (op)), "none"))
1119 godname = "A random spirit";
1120
1019 /* the caller should set caster to op if appropriate */ 1121 /* the caller should set caster to op if appropriate */
1020 if (!caster) { 1122 if (!caster)
1123 {
1021 LOG(llevError,"cast_spell: null caster object passed\n"); 1124 LOG (llevError, "cast_spell: null caster object passed\n");
1022 return 0; 1125 return 0;
1023 } 1126 }
1024 1127
1025 /* if caster is a spell casting object, this normally shouldn't be 1128 /* if caster is a spell casting object, this normally shouldn't be
1026 * an issue, because they don't have any spellpaths set up. 1129 * an issue, because they don't have any spellpaths set up.
1027 */ 1130 */
1028 if (caster->path_denied & spell_ob->path_attuned) { 1131 if (caster->path_denied & spell_ob->path_attuned && !QUERY_FLAG (caster, FLAG_WIZCAST))
1132 {
1029 new_draw_info(NDI_UNIQUE, 0,op, "That spell path is denied to you."); 1133 new_draw_info (NDI_UNIQUE, 0, op, "That spell path is denied to you.");
1030 return 0; 1134 return 0;
1031 } 1135 }
1032 1136
1033 /* if it is a player casting the spell, and they are really casting it 1137 /* if it is a player casting the spell, and they are really casting it
1034 * (vs it coming from a wand, scroll, or whatever else), do some 1138 * (vs it coming from a wand, scroll, or whatever else), do some
1035 * checks. We let monsters do special things - eg, they 1139 * checks. We let monsters do special things - eg, they
1036 * don't need the skill, bypass level checks, etc. The monster function 1140 * don't need the skill, bypass level checks, etc. The monster function
1037 * should take care of that. 1141 * should take care of that.
1038 * Remove the wiz check here and move it further down - some spells 1142 * Remove the wiz check here and move it further down - some spells
1039 * need to have the right skill pointer passed, so we need to 1143 * need to have the right skill pointer passed, so we need to
1040 * at least process that code. 1144 * at least process that code.
1041 */ 1145 */
1042 if (op->type == PLAYER && op == caster) { 1146 if (op->type == PLAYER && op == caster)
1147 {
1043 cast_level = caster_level(caster, spell_ob); 1148 cast_level = caster_level (caster, spell_ob);
1044 if (spell_ob->skill) { 1149 if (spell_ob->skill)
1150 {
1045 skill = find_skill_by_name(op, spell_ob->skill); 1151 skill = find_skill_by_name (op, spell_ob->skill);
1046 if (!skill) { 1152 if (!skill)
1047 new_draw_info_format(NDI_UNIQUE, 0,op,"You need the skill %s to cast %s.",
1048 spell_ob->skill, spell_ob->name);
1049 return 0;
1050 }
1051 if (min_casting_level(op, spell_ob) > cast_level && !QUERY_FLAG(op, FLAG_WIZ)) {
1052 new_draw_info(NDI_UNIQUE, 0,op, "You lack enough skill to cast that spell.");
1053 return 0;
1054 }
1055 }
1056 /* If the caster is the wiz, they don't ever fail, and don't have
1057 * to have sufficient grace/mana.
1058 */
1059 if (!QUERY_FLAG(op, FLAG_WIZ)) {
1060 if (SP_level_spellpoint_cost(caster, spell_ob, SPELL_MANA) &&
1061 SP_level_spellpoint_cost(caster, spell_ob, SPELL_MANA) > op->stats.sp) {
1062 new_draw_info(NDI_UNIQUE, 0,op,"You don't have enough mana.");
1063 return 0;
1064 }
1065 if (SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE) &&
1066 SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE) > op->stats.grace) {
1067 if(random_roll(0, op->stats.Wis-1, op, PREFER_HIGH) + op->stats.grace -
1068 10*SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE)/op->stats.maxgrace >0) {
1069 new_draw_info_format(NDI_UNIQUE, 0,op,
1070 "%s grants your prayer, though you are unworthy.",godname);
1071 }
1072 else {
1073 prayer_failure(op,op->stats.grace,
1074 SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE) - op->stats.grace);
1075 new_draw_info_format(NDI_UNIQUE, 0,op,"%s ignores your prayer.",godname);
1076 return 0;
1077 }
1078 }
1079
1080 /* player/monster is trying to cast the spell. might fumble it */
1081 if (spell_ob->stats.grace && random_roll(0, 99, op, PREFER_HIGH) <
1082 (spell_ob->level/(float)MAX(1,op->level) *cleric_chance[op->stats.Wis])) {
1083 play_sound_player_only(op->contr, SOUND_FUMBLE_SPELL,0,0);
1084 new_draw_info(NDI_UNIQUE, 0,op,"You fumble the spell.");
1085 if (settings.casting_time == TRUE) {
1086 op->casting_time = -1;
1087 }
1088 op->stats.grace -= random_roll(1, SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE), op, PREFER_LOW);
1089 return 0;
1090 } else if (spell_ob->stats.sp) {
1091 int failure = random_roll(0, 199, op, PREFER_HIGH) -
1092 op->contr->encumbrance +op->level - spell_ob->level +35;
1093
1094 if( failure < 0) {
1095 new_draw_info(NDI_UNIQUE, 0,op,"You bungle the spell because you have too much heavy equipment in use.");
1096 if (settings.spell_failure_effects == TRUE)
1097 spell_failure(op,failure,
1098 SP_level_spellpoint_cost(caster,spell_ob, SPELL_MANA),
1099 skill);
1100 op->contr->shoottype = (rangetype) old_shoottype;
1101 op->stats.sp -= random_roll(0, SP_level_spellpoint_cost(caster,spell_ob, SPELL_MANA), op, PREFER_LOW);
1102 return 0;
1103 }
1104 }
1105 }
1106 }
1107
1108 mflags = get_map_flags(op->map, NULL, op->x, op->y, NULL, NULL);
1109
1110 /* See if we can cast a spell here. If the caster and op are
1111 * not alive, then this would mean that the mapmaker put the
1112 * objects on the space - presume that they know what they are
1113 * doing.
1114 */
1115 if (spell_ob->type == SPELL
1116 && (mflags & P_SAFE || caster->type != POTION) // elmex: prevent potions from casting on safe maps
1117 && !QUERY_FLAG(op, FLAG_WIZCAST)
1118 && (QUERY_FLAG(caster, FLAG_ALIVE)
1119 || QUERY_FLAG(op, FLAG_ALIVE))
1120 && (((mflags & P_NO_MAGIC) && spell_ob->stats.sp)
1121 || ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)))
1122 {
1123 if (op->type!=PLAYER)
1124 return 0;
1125
1126 if ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)
1127 new_draw_info_format(NDI_UNIQUE, 0,op,"This ground is unholy! %s ignores you.",godname);
1128 else if (mflags & P_SAFE)
1129 new_draw_info(NDI_UNIQUE, 0,op,
1130 "This ground is sacred! The gods prevent any magical effects done by you here!.");
1131 else
1132 switch(op->contr->shoottype)
1133 { 1153 {
1154 new_draw_info_format (NDI_UNIQUE, 0, op, "You need the skill %s to cast %s.", &spell_ob->skill, &spell_ob->name);
1155 return 0;
1156 }
1157 if (min_casting_level (op, spell_ob) > cast_level && !QUERY_FLAG (op, FLAG_WIZ))
1158 {
1159 new_draw_info (NDI_UNIQUE, 0, op, "You lack enough skill to cast that spell.");
1160 return 0;
1161 }
1162 }
1163 /* If the caster is the wiz, they don't ever fail, and don't have
1164 * to have sufficient grace/mana.
1165 */
1166 if (!QUERY_FLAG (op, FLAG_WIZ))
1167 {
1168 if (SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA) &&
1169 SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA) > op->stats.sp)
1170 {
1171 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough mana.");
1172 return 0;
1173 }
1174 if (SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) &&
1175 SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) > op->stats.grace)
1176 {
1177 if (random_roll (0, op->stats.Wis - 1, op, PREFER_HIGH) + op->stats.grace -
1178 10 * SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) / op->stats.maxgrace > 0)
1179 {
1180 new_draw_info_format (NDI_UNIQUE, 0, op, "%s grants your prayer, though you are unworthy.", godname);
1181 }
1182 else
1183 {
1184 prayer_failure (op, op->stats.grace, SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) - op->stats.grace);
1185 new_draw_info_format (NDI_UNIQUE, 0, op, "%s ignores your prayer.", godname);
1186 return 0;
1187 }
1188 }
1189
1190 /* player/monster is trying to cast the spell. might fumble it */
1191 if (spell_ob->stats.grace && random_roll (0, 99, op, PREFER_HIGH) <
1192 (spell_ob->level / (float) MAX (1, op->level) * cleric_chance[op->stats.Wis]))
1193 {
1194 play_sound_player_only (op->contr, SOUND_FUMBLE_SPELL, 0, 0);
1195 new_draw_info (NDI_UNIQUE, 0, op, "You fumble the spell.");
1196 if (settings.casting_time == TRUE)
1197 {
1198 op->casting_time = -1;
1199 }
1200 op->stats.grace -= random_roll (1, SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE), op, PREFER_LOW);
1201 return 0;
1202 }
1203 else if (spell_ob->stats.sp)
1204 {
1205 int failure = random_roll (0, 199, op, PREFER_HIGH) - op->contr->encumbrance + op->level - spell_ob->level + 35;
1206
1207 if (failure < 0)
1208 {
1209 new_draw_info (NDI_UNIQUE, 0, op, "You bungle the spell because you have too much heavy equipment in use.");
1210 if (settings.spell_failure_effects == TRUE)
1211 spell_failure (op, failure, SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA), skill);
1212 op->contr->shoottype = (rangetype) old_shoottype;
1213 op->stats.sp -= random_roll (0, SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA), op, PREFER_LOW);
1214 return 0;
1215 }
1216 }
1217 }
1218 }
1219
1220 mflags = get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL);
1221
1222 /* See if we can cast a spell here. If the caster and op are
1223 * not alive, then this would mean that the mapmaker put the
1224 * objects on the space - presume that they know what they are
1225 * doing.
1226 */
1227
1228 if ((mflags & P_SAFE) && !QUERY_FLAG (op, FLAG_WIZCAST)) // There is _ABSOLUTELY_ no magic allowed here (except wizards :-)!
1229 {
1230 new_draw_info (NDI_UNIQUE, 0, op, "This ground is sacred! The gods prevent any magical effects done by you here!.");
1231 return 0;
1232 }
1233
1234 if ((spell_ob->type == SPELL)
1235 && (caster->type != POTION)
1236 && !QUERY_FLAG (op, FLAG_WIZCAST)
1237 && (QUERY_FLAG (caster, FLAG_ALIVE)
1238 || QUERY_FLAG (op, FLAG_ALIVE))
1239 && (((mflags & P_NO_MAGIC) && spell_ob->stats.sp) || ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)))
1240 {
1241 if (op->type != PLAYER)
1242 return 0;
1243
1244 if ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)
1245 new_draw_info_format (NDI_UNIQUE, 0, op, "This ground is unholy! %s ignores you.", godname);
1246 else
1247 switch (op->contr->shoottype)
1248 {
1134 case range_magic: 1249 case range_magic:
1135 new_draw_info(NDI_UNIQUE, 0,op,"Something blocks your spellcasting."); 1250 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your spellcasting.");
1136 break; 1251 break;
1137 case range_misc: 1252 case range_misc:
1138 new_draw_info(NDI_UNIQUE, 0,op,"Something blocks the magic of your item."); 1253 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of your item.");
1139 break; 1254 break;
1140 case range_golem: 1255 case range_golem:
1141 new_draw_info(NDI_UNIQUE, 0,op,"Something blocks the magic of your scroll."); 1256 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of your scroll.");
1142 break; 1257 break;
1143 default: 1258 default:
1144 break; 1259 break;
1260 }
1261 return 0;
1262 }
1263
1264 if (caster == op && settings.casting_time == TRUE && spell_ob->type == SPELL)
1265 {
1266 if (op->casting_time == -1)
1267 { /* begin the casting */
1268 op->casting_time = (sint16) (spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob));
1269 op->spell = spell_ob;
1270 /* put the stringarg into the object struct so that when the
1271 * spell is actually cast, it knows about the stringarg.
1272 * necessary for the invoke command spells.
1273 */
1274 if (stringarg)
1275 {
1276 op->spellarg = strdup (stringarg);
1145 } 1277 }
1146 return 0; 1278 else
1279 op->spellarg = NULL;
1280 return 0;
1147 } 1281 }
1148 1282 else if (op->casting_time != 0)
1149 if (caster == op && settings.casting_time == TRUE && spell_ob->type == SPELL) { 1283 {
1150 if (op->casting_time==-1) { /* begin the casting */ 1284 if (op->type == PLAYER)
1151 op->casting_time = (sint16) (spell_ob->casting_time*PATH_TIME_MULT(op,spell_ob)); 1285 new_draw_info (NDI_UNIQUE, 0, op, "You are casting!");
1152 op->spell = spell_ob; 1286 return 0;
1153 /* put the stringarg into the object struct so that when the 1287 }
1154 * spell is actually cast, it knows about the stringarg. 1288 else
1155 * necessary for the invoke command spells. 1289 { /* casting_time == 0 */
1156 */ 1290 op->casting_time = -1;
1157 if(stringarg) { 1291 spell_ob = op->spell;
1158 op->spellarg = strdup_local(stringarg); 1292 stringarg = op->spellarg;
1293 }
1159 } 1294 }
1160 else op->spellarg=NULL; 1295 else
1161 return 0; 1296 {
1162 }
1163 else if (op->casting_time != 0) {
1164 if (op->type == PLAYER )
1165 new_draw_info(NDI_UNIQUE, 0,op,"You are casting!");
1166 return 0;
1167 } else { /* casting_time == 0 */
1168 op->casting_time = -1;
1169 spell_ob = op->spell;
1170 stringarg = op->spellarg;
1171 }
1172 } else {
1173 /* Take into account how long it takes to cast the spell. 1297 /* Take into account how long it takes to cast the spell.
1174 * if the player is casting it, then we use the time in 1298 * if the player is casting it, then we use the time in
1175 * the spell object. If it is a spell object, have it 1299 * the spell object. If it is a spell object, have it
1176 * take two ticks. Things that cast spells on the players 1300 * take two ticks. Things that cast spells on the players
1177 * behalf (eg, altars, and whatever else) shouldn't cost 1301 * behalf (eg, altars, and whatever else) shouldn't cost
1178 * the player any time. 1302 * the player any time.
1179 * Ignore casting time for firewalls 1303 * Ignore casting time for firewalls
1180 */ 1304 */
1181 if (caster == op && caster->type != FIREWALL) { 1305 if (caster == op && caster->type != FIREWALL)
1306 {
1182 op->speed_left -= spell_ob->casting_time*PATH_TIME_MULT(op,spell_ob) * FABS(op->speed); 1307 op->speed_left -= spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed);
1183 /* Other portions of the code may also decrement the speed of the player, so 1308 /* Other portions of the code may also decrement the speed of the player, so
1184 * put a lower limit so that the player isn't stuck here too long 1309 * put a lower limit so that the player isn't stuck here too long
1185 */ 1310 */
1186 if ((spell_ob->casting_time > 0) &&
1187 op->speed_left < -spell_ob->casting_time*PATH_TIME_MULT(op,spell_ob) * FABS(op->speed)) 1311 if ((spell_ob->casting_time > 0) && op->speed_left < -spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed))
1188 op->speed_left = -spell_ob->casting_time*PATH_TIME_MULT(op,spell_ob) * FABS(op->speed); 1312 op->speed_left = -spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed);
1189 } else if (caster->type == WAND || caster->type == HORN || 1313 }
1190 caster->type == ROD || caster->type == POTION || 1314 else if (caster->type == WAND || caster->type == HORN || caster->type == ROD || caster->type == POTION || caster->type == SCROLL)
1191 caster->type == SCROLL) { 1315 {
1192 op->speed_left -= 2 * FABS(op->speed); 1316 op->speed_left -= 2 * FABS (op->speed);
1193 } 1317 }
1194 } 1318 }
1195 1319
1196 if (op->type == PLAYER && op == caster) { 1320 if (op->type == PLAYER && op == caster)
1321 {
1197 op->stats.grace -= SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE); 1322 op->stats.grace -= SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE);
1198 op->stats.sp -= SP_level_spellpoint_cost(caster,spell_ob, SPELL_MANA); 1323 op->stats.sp -= SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA);
1199 } 1324 }
1200 1325
1201 /* We want to try to find the skill to properly credit exp. 1326 /* We want to try to find the skill to properly credit exp.
1202 * for spell casting objects, the exp goes to the skill the casting 1327 * for spell casting objects, the exp goes to the skill the casting
1203 * object requires. 1328 * object requires.
1204 */ 1329 */
1205 if (op != caster && !skill && caster->skill) { 1330 if (op != caster && !skill && caster->skill)
1331 {
1206 skill = find_skill_by_name(op, caster->skill); 1332 skill = find_skill_by_name (op, caster->skill);
1207 if (!skill) { 1333 if (!skill)
1334 {
1208 new_draw_info_format(NDI_UNIQUE, 0,op,"You lack the skill %s to use the %s", 1335 new_draw_info_format (NDI_UNIQUE, 0, op, "You lack the skill %s to use the %s", &caster->skill, query_name (caster));
1209 caster->skill, query_name(caster));
1210 return 0; 1336 return 0;
1211 } 1337 }
1212 change_skill(op, skill, 0); /* needed for proper exp credit */ 1338 change_skill (op, skill, 0); /* needed for proper exp credit */
1213 } 1339 }
1214 1340
1215 switch(spell_ob->subtype) { 1341 switch (spell_ob->subtype)
1342 {
1216 /* The order of case statements is same as the order they show up 1343 /* The order of case statements is same as the order they show up
1217 * in in spells.h. 1344 * in in spells.h.
1218 */ 1345 */
1219 case SP_RAISE_DEAD: 1346 case SP_RAISE_DEAD:
1220 success = cast_raise_dead_spell(op,caster, spell_ob, dir,stringarg); 1347 success = cast_raise_dead_spell (op, caster, spell_ob, dir, stringarg);
1221 break; 1348 break;
1222 1349
1223 case SP_RUNE: 1350 case SP_RUNE:
1224 success = write_rune(op,caster, spell_ob, dir,stringarg); 1351 success = write_rune (op, caster, spell_ob, dir, stringarg);
1225 break; 1352 break;
1226 1353
1227 case SP_MAKE_MARK: 1354 case SP_MAKE_MARK:
1228 success = write_mark(op, spell_ob, stringarg); 1355 success = write_mark (op, spell_ob, stringarg);
1229 break; 1356 break;
1230 1357
1231 case SP_BOLT: 1358 case SP_BOLT:
1232 success = fire_bolt(op,caster,dir,spell_ob,skill); 1359 success = fire_bolt (op, caster, dir, spell_ob, skill);
1233 break; 1360 break;
1234 1361
1235 case SP_BULLET: 1362 case SP_BULLET:
1236 success = fire_bullet(op, caster, dir, spell_ob); 1363 success = fire_bullet (op, caster, dir, spell_ob);
1237 break; 1364 break;
1238 1365
1239 case SP_CONE: 1366 case SP_CONE:
1240 success = cast_cone(op, caster, dir, spell_ob); 1367 success = cast_cone (op, caster, dir, spell_ob);
1241 break; 1368 break;
1242 1369
1243 case SP_BOMB: 1370 case SP_BOMB:
1244 success = create_bomb(op,caster,dir, spell_ob); 1371 success = create_bomb (op, caster, dir, spell_ob);
1245 break; 1372 break;
1246 1373
1247 case SP_WONDER: 1374 case SP_WONDER:
1248 success = cast_wonder(op,caster, dir,spell_ob); 1375 success = cast_wonder (op, caster, dir, spell_ob);
1249 break; 1376 break;
1250 1377
1251 case SP_SMITE: 1378 case SP_SMITE:
1252 success = cast_smite_spell(op,caster, dir,spell_ob); 1379 success = cast_smite_spell (op, caster, dir, spell_ob);
1253 break; 1380 break;
1254 1381
1255 case SP_MAGIC_MISSILE: 1382 case SP_MAGIC_MISSILE:
1256 success = fire_arch_from_position(op, caster, op->x + freearr_x[dir], 1383 success = fire_arch_from_position (op, caster, op->x + freearr_x[dir], op->y + freearr_y[dir], dir, spell_ob);
1257 op->y + freearr_y[dir], dir, spell_ob);
1258 break; 1384 break;
1259 1385
1260 case SP_SUMMON_GOLEM: 1386 case SP_SUMMON_GOLEM:
1261 success = summon_golem(op, caster, dir, spell_ob); 1387 success = summon_golem (op, caster, dir, spell_ob);
1262 old_shoottype = range_golem; 1388 old_shoottype = range_golem;
1263 break; 1389 break;
1264 1390
1265 case SP_DIMENSION_DOOR: 1391 case SP_DIMENSION_DOOR:
1266 /* dimension door needs the actual caster, because that is what is 1392 /* dimension door needs the actual caster, because that is what is
1267 * moved. 1393 * moved.
1268 */ 1394 */
1269 success = dimension_door(op,caster, spell_ob, dir); 1395 success = dimension_door (op, caster, spell_ob, dir);
1270 break; 1396 break;
1271 1397
1272 case SP_MAGIC_MAPPING: 1398 case SP_MAGIC_MAPPING:
1273 if(op->type==PLAYER) { 1399 if (op->type == PLAYER)
1400 {
1274 spell_effect(spell_ob, op->x, op->y, op->map, op); 1401 spell_effect (spell_ob, op->x, op->y, op->map, op);
1275 draw_magic_map(op); 1402 draw_magic_map (op);
1276 success=1; 1403 success = 1;
1277 } 1404 }
1278 else success=0; 1405 else
1406 success = 0;
1279 break; 1407 break;
1280 1408
1281 case SP_MAGIC_WALL: 1409 case SP_MAGIC_WALL:
1282 success = magic_wall(op,caster,dir,spell_ob); 1410 success = magic_wall (op, caster, dir, spell_ob);
1283 break; 1411 break;
1284 1412
1285 case SP_DESTRUCTION: 1413 case SP_DESTRUCTION:
1286 success = cast_destruction(op,caster,spell_ob); 1414 success = cast_destruction (op, caster, spell_ob);
1287 break; 1415 break;
1288 1416
1289 case SP_PERCEIVE_SELF: 1417 case SP_PERCEIVE_SELF:
1290 success = perceive_self(op); 1418 success = perceive_self (op);
1291 break; 1419 break;
1292 1420
1293 case SP_WORD_OF_RECALL: 1421 case SP_WORD_OF_RECALL:
1294 success = cast_word_of_recall(op,caster,spell_ob); 1422 success = cast_word_of_recall (op, caster, spell_ob);
1295 break; 1423 break;
1296 1424
1297 case SP_INVISIBLE: 1425 case SP_INVISIBLE:
1298 success = cast_invisible(op,caster,spell_ob); 1426 success = cast_invisible (op, caster, spell_ob);
1299 break; 1427 break;
1300 1428
1301 case SP_PROBE: 1429 case SP_PROBE:
1302 success = probe(op,caster, spell_ob, dir); 1430 success = probe (op, caster, spell_ob, dir);
1303 break; 1431 break;
1304 1432
1305 case SP_HEALING: 1433 case SP_HEALING:
1306 success = cast_heal(op,caster, spell_ob, dir); 1434 success = cast_heal (op, caster, spell_ob, dir);
1307 break; 1435 break;
1308 1436
1309 case SP_CREATE_FOOD: 1437 case SP_CREATE_FOOD:
1310 success = cast_create_food(op,caster,spell_ob, dir,stringarg); 1438 success = cast_create_food (op, caster, spell_ob, dir, stringarg);
1311 break; 1439 break;
1312 1440
1313 case SP_EARTH_TO_DUST: 1441 case SP_EARTH_TO_DUST:
1314 success = cast_earth_to_dust(op,caster,spell_ob); 1442 success = cast_earth_to_dust (op, caster, spell_ob);
1315 break; 1443 break;
1316 1444
1317 case SP_CHANGE_ABILITY: 1445 case SP_CHANGE_ABILITY:
1318 success = cast_change_ability(op,caster,spell_ob, dir, 0); 1446 success = cast_change_ability (op, caster, spell_ob, dir, 0);
1319 break; 1447 break;
1320 1448
1321 case SP_BLESS: 1449 case SP_BLESS:
1322 success = cast_bless(op,caster,spell_ob, dir); 1450 success = cast_bless (op, caster, spell_ob, dir);
1323 break; 1451 break;
1324 1452
1325 case SP_CURSE: 1453 case SP_CURSE:
1326 success = cast_curse(op,caster,spell_ob, dir); 1454 success = cast_curse (op, caster, spell_ob, dir);
1327 break; 1455 break;
1328 1456
1329 case SP_SUMMON_MONSTER: 1457 case SP_SUMMON_MONSTER:
1330 success = summon_object(op,caster,spell_ob, dir,stringarg); 1458 success = summon_object (op, caster, spell_ob, dir, stringarg);
1331 break; 1459 break;
1332 1460
1333 case SP_CHARGING: 1461 case SP_CHARGING:
1334 success = recharge(op, caster, spell_ob); 1462 success = recharge (op, caster, spell_ob);
1335 break; 1463 break;
1336 1464
1337 case SP_POLYMORPH: 1465 case SP_POLYMORPH:
1338#ifdef NO_POLYMORPH 1466#ifdef NO_POLYMORPH
1339 /* Not great, but at least provide feedback so if players do have 1467 /* Not great, but at least provide feedback so if players do have
1340 * polymorph (ie, find it as a preset item or left over from before 1468 * polymorph (ie, find it as a preset item or left over from before
1341 * it was disabled), they get some feedback. 1469 * it was disabled), they get some feedback.
1342 */ 1470 */
1343 new_draw_info(NDI_UNIQUE, 0,op,"The spell fizzles"); 1471 new_draw_info (NDI_UNIQUE, 0, op, "The spell fizzles");
1344 success = 0; 1472 success = 0;
1345#else 1473#else
1346 success = cast_polymorph(op,caster,spell_ob, dir); 1474 success = cast_polymorph (op, caster, spell_ob, dir);
1347#endif 1475#endif
1348 break; 1476 break;
1349 1477
1350 case SP_ALCHEMY: 1478 case SP_ALCHEMY:
1351 success = alchemy(op, caster, spell_ob); 1479 success = alchemy (op, caster, spell_ob);
1352 break; 1480 break;
1353 1481
1354 case SP_REMOVE_CURSE: 1482 case SP_REMOVE_CURSE:
1355 success = remove_curse(op, caster, spell_ob); 1483 success = remove_curse (op, caster, spell_ob);
1356 break; 1484 break;
1357 1485
1358 case SP_IDENTIFY: 1486 case SP_IDENTIFY:
1359 success = cast_identify(op, caster, spell_ob); 1487 success = cast_identify (op, caster, spell_ob);
1360 break; 1488 break;
1361 1489
1362 case SP_DETECTION: 1490 case SP_DETECTION:
1363 success = cast_detection(op, caster, spell_ob, skill); 1491 success = cast_detection (op, caster, spell_ob, skill);
1364 break; 1492 break;
1365 1493
1366 case SP_MOOD_CHANGE: 1494 case SP_MOOD_CHANGE:
1367 success = mood_change(op, caster, spell_ob); 1495 success = mood_change (op, caster, spell_ob);
1368 break; 1496 break;
1369 1497
1370 case SP_MOVING_BALL: 1498 case SP_MOVING_BALL:
1371 if (spell_ob->path_repelled &&
1372 (spell_ob->path_repelled & caster->path_attuned) != spell_ob->path_repelled) { 1499 if (spell_ob->path_repelled && (spell_ob->path_repelled & caster->path_attuned) != spell_ob->path_repelled)
1373 new_draw_info_format(NDI_UNIQUE, 0, op, 1500 {
1374 "You lack the proper attunement to cast %s", spell_ob->name); 1501 new_draw_info_format (NDI_UNIQUE, 0, op, "You lack the proper attunement to cast %s", &spell_ob->name);
1375 success = 0; 1502 success = 0;
1376 } else 1503 }
1377 success = fire_arch_from_position(op,caster, 1504 else
1378 op->x + freearr_x[dir], op->y + freearr_y[dir], 1505 success = fire_arch_from_position (op, caster, op->x + freearr_x[dir], op->y + freearr_y[dir], dir, spell_ob);
1379 dir, spell_ob);
1380 break; 1506 break;
1381 1507
1382 case SP_SWARM: 1508 case SP_SWARM:
1383 success = fire_swarm(op, caster, spell_ob, dir); 1509 success = fire_swarm (op, caster, spell_ob, dir);
1384 break; 1510 break;
1385 1511
1386 case SP_CHANGE_MANA: 1512 case SP_CHANGE_MANA:
1387 success = cast_transfer(op,caster, spell_ob, dir); 1513 success = cast_transfer (op, caster, spell_ob, dir);
1388 break; 1514 break;
1389 1515
1390 case SP_DISPEL_RUNE: 1516 case SP_DISPEL_RUNE:
1391 /* in rune.c */ 1517 /* in rune.c */
1392 success = dispel_rune(op,caster, spell_ob, skill, dir); 1518 success = dispel_rune (op, caster, spell_ob, skill, dir);
1393 break; 1519 break;
1394 1520
1395 case SP_CREATE_MISSILE: 1521 case SP_CREATE_MISSILE:
1396 success = cast_create_missile(op,caster,spell_ob, dir,stringarg); 1522 success = cast_create_missile (op, caster, spell_ob, dir, stringarg);
1397 break; 1523 break;
1398 1524
1399 case SP_CONSECRATE: 1525 case SP_CONSECRATE:
1400 success = cast_consecrate(op, caster, spell_ob); 1526 success = cast_consecrate (op, caster, spell_ob);
1401 break; 1527 break;
1402 1528
1403 case SP_ANIMATE_WEAPON: 1529 case SP_ANIMATE_WEAPON:
1404 success = animate_weapon(op, caster, spell_ob, dir); 1530 success = animate_weapon (op, caster, spell_ob, dir);
1405 old_shoottype = range_golem; 1531 old_shoottype = range_golem;
1406 break; 1532 break;
1407 1533
1408 case SP_LIGHT: 1534 case SP_LIGHT:
1409 success = cast_light(op, caster, spell_ob, dir); 1535 success = cast_light (op, caster, spell_ob, dir);
1410 break; 1536 break;
1411 1537
1412 case SP_CHANGE_MAP_LIGHT: 1538 case SP_CHANGE_MAP_LIGHT:
1413 success = cast_change_map_lightlevel(op, caster, spell_ob); 1539 success = cast_change_map_lightlevel (op, caster, spell_ob);
1414 break; 1540 break;
1415 1541
1416 case SP_FAERY_FIRE: 1542 case SP_FAERY_FIRE:
1417 success = cast_destruction(op,caster,spell_ob); 1543 success = cast_destruction (op, caster, spell_ob);
1418 break; 1544 break;
1419 1545
1420 case SP_CAUSE_DISEASE: 1546 case SP_CAUSE_DISEASE:
1421 success = cast_cause_disease(op, caster, spell_ob, dir); 1547 success = cast_cause_disease (op, caster, spell_ob, dir);
1422 break; 1548 break;
1423 1549
1424 case SP_AURA: 1550 case SP_AURA:
1425 success = create_aura(op, caster, spell_ob); 1551 success = create_aura (op, caster, spell_ob);
1426 break; 1552 break;
1427 1553
1428 case SP_TOWN_PORTAL: 1554 case SP_TOWN_PORTAL:
1429 success= cast_create_town_portal (op,caster,spell_ob, dir); 1555 success = cast_create_town_portal (op, caster, spell_ob, dir);
1430 break; 1556 break;
1431 1557
1432 case SP_PARTY_SPELL: 1558 case SP_PARTY_SPELL:
1433 success = cast_party_spell (op, caster, dir, spell_ob, stringarg); 1559 success = cast_party_spell (op, caster, dir, spell_ob, stringarg);
1434 break; 1560 break;
1435 1561
1436 default: 1562 default:
1437 if (!INVOKE_OBJECT (CAST_SPELL, spell_ob, ARG_OBJECT (op), ARG_OBJECT (caster), ARG_INT (dir), ARG_STRING (stringarg))) 1563 if (!INVOKE_OBJECT (CAST_SPELL, spell_ob, ARG_OBJECT (op), ARG_OBJECT (caster), ARG_INT (dir), ARG_STRING (stringarg)))
1438 LOG (llevError,"cast_spell: Unhandled spell subtype %d\n", 1564 LOG (llevError, "cast_spell: Unhandled spell subtype %d\n", spell_ob->subtype);
1439 spell_ob->subtype);
1440
1441
1442 } 1565 }
1443 1566
1444 /* FIXME - we need some better sound suppport */ 1567 /* FIXME - we need some better sound suppport */
1445 // yes, for example, augment map info with the spell effect 1568 // yes, for example, augment map info with the spell effect
1446 // so clients can calculate the sounds themselves 1569 // so clients can calculate the sounds themselves
1447 //play_sound_map(op->map, op->x, op->y, SOUND_CAST_SPELL_0 + spell_ob->subtype); 1570 //play_sound_map(op->map, op->x, op->y, SOUND_CAST_SPELL_0 + spell_ob->subtype);
1448 1571
1449 /* free the spell arg */ 1572 /* free the spell arg */
1450 if(settings.casting_time == TRUE && stringarg) { 1573 if (settings.casting_time == TRUE && stringarg)
1451 free(stringarg);
1452 stringarg=NULL;
1453 } 1574 {
1575 free (stringarg);
1576 stringarg = NULL;
1577 }
1454 /* perhaps a bit of a hack, but if using a wand, it has to change the skill 1578 /* perhaps a bit of a hack, but if using a wand, it has to change the skill
1455 * to something like use_magic_item, but you really want to be able to fire 1579 * to something like use_magic_item, but you really want to be able to fire
1456 * it again. 1580 * it again.
1457 */ 1581 */
1582 if (op->contr)
1458 if (op->contr) op->contr->shoottype = (rangetype) old_shoottype; 1583 op->contr->shoottype = (rangetype) old_shoottype;
1459 1584
1460 return success; 1585 return success;
1461} 1586}
1462 1587
1463 1588
1464/* This is called from time.c/process_object(). That function 1589/* This is called from time.c/process_object(). That function
1465 * calls this for any SPELL_EFFECT type objects. This function 1590 * calls this for any SPELL_EFFECT type objects. This function
1466 * then dispatches them to the appropriate specific routines. 1591 * then dispatches them to the appropriate specific routines.
1467 */ 1592 */
1593void
1468void move_spell_effect(object *op) { 1594move_spell_effect (object *op)
1469 1595{
1470 switch (op->subtype) { 1596 switch (op->subtype)
1597 {
1471 case SP_BOLT: 1598 case SP_BOLT:
1472 move_bolt(op); 1599 move_bolt (op);
1473 break; 1600 break;
1474 1601
1475 case SP_BULLET: 1602 case SP_BULLET:
1476 move_bullet(op); 1603 move_bullet (op);
1477 break; 1604 break;
1478 1605
1479 case SP_EXPLOSION: 1606 case SP_EXPLOSION:
1480 explosion(op); 1607 explosion (op);
1481 break; 1608 break;
1482 1609
1483 case SP_CONE: 1610 case SP_CONE:
1484 move_cone(op); 1611 move_cone (op);
1485 break; 1612 break;
1486 1613
1487 case SP_BOMB: 1614 case SP_BOMB:
1488 animate_bomb(op); 1615 animate_bomb (op);
1489 break; 1616 break;
1490 1617
1491 case SP_MAGIC_MISSILE: 1618 case SP_MAGIC_MISSILE:
1492 move_missile(op); 1619 move_missile (op);
1493 break; 1620 break;
1494 1621
1495 case SP_WORD_OF_RECALL: 1622 case SP_WORD_OF_RECALL:
1496 execute_word_of_recall(op); 1623 execute_word_of_recall (op);
1497 break; 1624 break;
1498 1625
1499 case SP_MOVING_BALL: 1626 case SP_MOVING_BALL:
1500 move_ball_spell(op); 1627 move_ball_spell (op);
1501 break; 1628 break;
1502 1629
1503 case SP_SWARM: 1630 case SP_SWARM:
1504 move_swarm_spell(op); 1631 move_swarm_spell (op);
1505 break; 1632 break;
1506 1633
1507 case SP_AURA: 1634 case SP_AURA:
1508 move_aura(op); 1635 move_aura (op);
1509 break; 1636 break;
1510
1511 } 1637 }
1512} 1638}
1513 1639
1514/* this checks to see if something special should happen if 1640/* this checks to see if something special should happen if
1515 * something runs into the object. 1641 * something runs into the object.
1516 */ 1642 */
1643void
1517void check_spell_effect(object *op) { 1644check_spell_effect (object *op)
1518 1645{
1519 switch (op->subtype) { 1646 switch (op->subtype)
1647 {
1520 case SP_BOLT: 1648 case SP_BOLT:
1521 move_bolt(op); 1649 move_bolt (op);
1522 return; 1650 return;
1523 1651
1524 case SP_BULLET: 1652 case SP_BULLET:
1525 check_bullet(op); 1653 check_bullet (op);
1526 return; 1654 return;
1527 } 1655 }
1528
1529} 1656}
1530 1657
1531/* This is called by move_apply. Basically, if someone 1658/* This is called by move_apply. Basically, if someone
1532 * moves onto a spell effect and the walk_on or fly_on flags 1659 * moves onto a spell effect and the walk_on or fly_on flags
1533 * are set, this is called. This should only be called for 1660 * are set, this is called. This should only be called for
1534 * objects of the appropraite type. 1661 * objects of the appropraite type.
1535 */ 1662 */
1663void
1536void apply_spell_effect(object *spell, object *victim) 1664apply_spell_effect (object *spell, object *victim)
1537{ 1665{
1538 switch (spell->subtype) { 1666 switch (spell->subtype)
1667 {
1539 case SP_CONE: 1668 case SP_CONE:
1540 if (QUERY_FLAG(victim, FLAG_ALIVE) && spell->speed && spell->attacktype) 1669 if (QUERY_FLAG (victim, FLAG_ALIVE) && spell->speed && spell->attacktype)
1541 hit_player(victim, spell->stats.dam, spell, spell->attacktype, 0); 1670 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 0);
1542 break; 1671 break;
1543 1672
1544 case SP_MAGIC_MISSILE: 1673 case SP_MAGIC_MISSILE:
1545 if (QUERY_FLAG (victim, FLAG_ALIVE)) {
1546 tag_t spell_tag = spell->count;
1547 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
1548 if ( ! was_destroyed (spell, spell_tag)) {
1549 remove_ob (spell);
1550 free_object (spell);
1551 }
1552 }
1553 break;
1554
1555 case SP_MOVING_BALL:
1556 if (QUERY_FLAG (victim, FLAG_ALIVE)) 1674 if (QUERY_FLAG (victim, FLAG_ALIVE))
1675 {
1676 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
1677
1678 if (!spell->destroyed ())
1679 spell->destroy ();
1680 }
1681 break;
1682
1683 case SP_MOVING_BALL:
1684 if (QUERY_FLAG (victim, FLAG_ALIVE))
1557 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1); 1685 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
1558 else if (victim->material || victim->materialname) 1686 else if (victim->material || victim->materialname)
1559 save_throw_object (victim, spell->attacktype, spell); 1687 save_throw_object (victim, spell->attacktype, spell);
1560 break; 1688 break;
1561 } 1689 }
1562} 1690}

Diff Legend

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