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.4 by root, Fri Aug 25 17:11:53 2006 UTC vs.
Revision 1.24 by root, Wed Dec 20 09:14:22 2006 UTC

1/*
2 * static char *rcsid_spell_util_c =
3 * "$Id: spell_util.C,v 1.4 2006/08/25 17:11:53 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 || sp_op->type == LIGHTNING // XXX: elmex: why is LIGHTNING special cased here?
450 // most spells use subtypes for bolts today...
451 || (rndm (0, 99)) < 90 - (sp_op->level / 10)))
452 return 1;
453
454 return 0;
414} 455}
415 456
416/* cast_create_object: creates object new_op in direction dir 457/* cast_create_object: creates object new_op in direction dir
417 * or if that is blocked, beneath the player (op). 458 * or if that is blocked, beneath the player (op).
418 * we pass 'caster', but don't use it for anything. 459 * we pass 'caster', but don't use it for anything.
419 * This is really just a simple wrapper function . 460 * This is really just a simple wrapper function .
420 * returns the direction that the object was actually placed 461 * returns the direction that the object was actually placed
421 * in. 462 * in.
422 */ 463 */
464int
423int cast_create_obj(object *op,object *caster,object *new_op, int dir) 465cast_create_obj (object *op, object *caster, object *new_op, int dir)
424{ 466{
425 mapstruct *m; 467 maptile *m;
426 sint16 sx, sy; 468 sint16 sx, sy;
427 469
428 if(dir && 470 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) || 471 ((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)))) { 472 OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))))
473 {
431 new_draw_info(NDI_UNIQUE, 0,op,"Something is in the way."); 474 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."); 475 new_draw_info (NDI_UNIQUE, 0, op, "You cast it at your feet.");
433 dir = 0; 476 dir = 0;
434 } 477 }
435 new_op->x=op->x+freearr_x[dir]; 478 new_op->x = op->x + freearr_x[dir];
436 new_op->y=op->y+freearr_y[dir]; 479 new_op->y = op->y + freearr_y[dir];
437 if (dir == 0) 480 if (dir == 0)
438 insert_ob_in_map(new_op,op->map,op,INS_BELOW_ORIGINATOR); 481 insert_ob_in_map (new_op, op->map, op, INS_BELOW_ORIGINATOR);
439 else 482 else
440 insert_ob_in_map(new_op,op->map,op,0); 483 insert_ob_in_map (new_op, op->map, op, 0);
441 return dir; 484 return dir;
442} 485}
443 486
444/* Returns true if it is ok to put spell *op on the space/may provided. 487/* 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 488 * immune_stop is basically the attacktype of the spell (why
446 * passed as a different value, not sure of). If immune_stop 489 * passed as a different value, not sure of). If immune_stop
… …
448 * on the space, the object doesn't get placed. if immune stop 491 * 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. 492 * does not have AT_MAGIC, then counterwalls do not effect the spell.
450 * 493 *
451 */ 494 */
452 495
496int
453int ok_to_put_more(mapstruct *m,sint16 x,sint16 y,object *op,int immune_stop) { 497ok_to_put_more (maptile *m, sint16 x, sint16 y, object *op, int immune_stop)
498{
454 object *tmp; 499 object *tmp;
455 int mflags; 500 int mflags;
456 mapstruct *mp; 501 maptile *mp;
457 502
458 mp = m; 503 mp = m;
459 mflags = get_map_flags(m, &mp, x, y, &x, &y); 504 mflags = get_map_flags (m, &mp, x, y, &x, &y);
460 505
461 if (mflags & P_OUT_OF_MAP) return 0; 506 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; 507 return 0;
490 508
509 if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (mp, x, y)))
510 return 0;
511
512 for (tmp = GET_MAP_OB (mp, x, y); tmp != NULL; tmp = tmp->above)
513 {
514 /* If there is a counterspell on the space, and this
515 * object is using magic, don't progress. I believe we could
516 * leave this out and let in progress, and other areas of the code
517 * will then remove it, but that would seem to to use more
518 * resources, and may not work as well if a player is standing
519 * on top of a counterwall spell (may hit the player before being
520 * removed.) On the other hand, it may be more dramatic for the
521 * spell to actually hit the counterwall and be sucked up.
522 */
523 if ((tmp->attacktype & AT_COUNTERSPELL) &&
524 (tmp->type != PLAYER) && !QUERY_FLAG (tmp, FLAG_MONSTER) &&
525 (tmp->type != WEAPON) && (tmp->type != BOW) && (tmp->type != ARROW) && (tmp->type != GOLEM) && (immune_stop & AT_MAGIC))
526 return 0;
527
528 /* This is to prevent 'out of control' spells. Basically, this
529 * limits one spell effect per space per spell. This is definately
530 * needed for performance reasons, and just for playability I believe.
531 * there are no such things as multispaced spells right now, so
532 * we don't need to worry about the head.
533 */
534 if ((tmp->stats.maxhp == op->stats.maxhp) && (tmp->type == op->type) && (tmp->subtype == op->subtype))
535 return 0;
536
491 /* 537 /*
492 * Combine similar spell effects into one spell effect. Needed for 538 * Combine similar spell effects into one spell effect. Needed for
493 * performance reasons with meteor swarm and the like, but also for 539 * performance reasons with meteor swarm and the like, but also for
494 * playability reasons. 540 * playability reasons.
495 */ 541 */
496 if (tmp->arch == op->arch 542 if (tmp->arch == op->arch
497 && tmp->type == op->type 543 && tmp->type == op->type
498 && tmp->subtype == op->subtype 544 && tmp->subtype == op->subtype
499 && tmp->owner == op->owner 545 && 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 ) { 546 {
503 tmp->stats.dam = MAX (tmp->stats.dam, op->stats.dam); 547 tmp->stats.dam = MAX (tmp->stats.dam, op->stats.dam);
504 tmp->range = MAX (tmp->range, op->range); 548 tmp->range = MAX (tmp->range, op->range);
505 tmp->duration = MAX (tmp->duration, op->duration); 549 tmp->duration = MAX (tmp->duration, op->duration);
506 return 0; 550 return 0;
507 } 551 }
508 552
509 /* Perhaps we should also put checks in for no magic and unholy 553 /* Perhaps we should also put checks in for no magic and unholy
510 * ground to prevent it from moving along? 554 * ground to prevent it from moving along?
511 */ 555 */
512 } 556 }
513 /* If it passes the above tests, it must be OK */ 557 /* If it passes the above tests, it must be OK */
514 return 1; 558 return 1;
515} 559}
516 560
517/* fire_arch_from_position: fires an archetype. 561/* fire_arch_from_position: fires an archetype.
518 * op: person firing the object. 562 * op: person firing the object.
519 * caster: object casting the spell. 563 * caster: object casting the spell.
… …
522 * dir: direction to fire in. 566 * dir: direction to fire in.
523 * spell: spell that is being fired. It uses other_arch for the archetype 567 * spell: spell that is being fired. It uses other_arch for the archetype
524 * to fire. 568 * to fire.
525 * returns 0 on failure, 1 on success. 569 * returns 0 on failure, 1 on success.
526 */ 570 */
527 571
572int
528int fire_arch_from_position (object *op, object *caster, sint16 x, sint16 y, 573fire_arch_from_position (object *op, object *caster, sint16 x, sint16 y, int dir, object *spell)
529 int dir, object *spell)
530{ 574{
531 object *tmp; 575 object *tmp;
532 int mflags; 576 int mflags;
533 mapstruct *m; 577 maptile *m;
534 578
535 if(spell->other_arch==NULL) 579 if (spell->other_arch == NULL)
536 return 0; 580 return 0;
537 581
538 m = op->map; 582 m = op->map;
539 mflags = get_map_flags(m, &m, x, y, &x, &y); 583 mflags = get_map_flags (m, &m, x, y, &x, &y);
540 if (mflags & P_OUT_OF_MAP) { 584 if (mflags & P_OUT_OF_MAP)
541 return 0;
542 } 585 {
586 return 0;
587 }
543 588
544 tmp=arch_to_object(spell->other_arch); 589 tmp = arch_to_object (spell->other_arch);
545 590
546 if(tmp==NULL) 591 if (tmp == NULL)
547 return 0; 592 return 0;
548 593
549 if (OB_TYPE_MOVE_BLOCK(tmp, GET_MAP_MOVE_BLOCK(m, x, y))) { 594 if (OB_TYPE_MOVE_BLOCK (tmp, GET_MAP_MOVE_BLOCK (m, x, y)))
595 {
550 new_draw_info(NDI_UNIQUE, 0, op, "You can't cast the spell on top of a wall!\n"); 596 new_draw_info (NDI_UNIQUE, 0, op, "You can't cast the spell on top of a wall!\n");
551 free_object(tmp); 597 tmp->destroy ();
552 return 0; 598 return 0;
553 } 599 }
554 600
555
556
557 tmp->stats.dam=spell->stats.dam+SP_level_dam_adjust(caster,spell); 601 tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
558 tmp->duration=spell->duration+SP_level_duration_adjust(caster,spell); 602 tmp->duration = spell->duration + SP_level_duration_adjust (caster, spell);
559 /* code in time.c uses food for some things, duration for others */ 603 /* code in time.c uses food for some things, duration for others */
560 tmp->stats.food = tmp->duration; 604 tmp->stats.food = tmp->duration;
561 tmp->range=spell->range+SP_level_range_adjust(caster,spell); 605 tmp->range = spell->range + SP_level_range_adjust (caster, spell);
562 tmp->attacktype = spell->attacktype; 606 tmp->attacktype = spell->attacktype;
563 tmp->x=x; 607 tmp->x = x;
564 tmp->y=y; 608 tmp->y = y;
565 tmp->direction=dir; 609 tmp->direction = dir;
566 if (get_owner (op) != NULL) 610 if (op->owner != NULL)
567 copy_owner (tmp, op); 611 tmp->set_owner (op);
568 else 612 else
569 set_owner (tmp, op); 613 tmp->set_owner (op);
570 tmp->level = caster_level (caster, spell); 614 tmp->level = caster_level (caster, spell);
571 set_spell_skill(op, caster, spell, tmp); 615 set_spell_skill (op, caster, spell, tmp);
572 616
573 /* needed for AT_HOLYWORD,AT_GODPOWER stuff */ 617 /* needed for AT_HOLYWORD,AT_GODPOWER stuff */
574 if(tmp->attacktype&AT_HOLYWORD || tmp->attacktype&AT_GODPOWER) { 618 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
575 if(!tailor_god_spell(tmp,op)) return 0;
576 } 619 {
620 if (!tailor_god_spell (tmp, op))
621 return 0;
622 }
577 if(QUERY_FLAG(tmp, FLAG_IS_TURNABLE)) 623 if (QUERY_FLAG (tmp, FLAG_IS_TURNABLE))
578 SET_ANIMATION(tmp, dir); 624 SET_ANIMATION (tmp, dir);
579 625
580 if ((tmp = insert_ob_in_map (tmp, m, op,0)) == NULL) 626 if ((tmp = insert_ob_in_map (tmp, m, op, 0)) == NULL)
581 return 1;
582
583 move_spell_effect(tmp);
584
585 return 1; 627 return 1;
628
629 move_spell_effect (tmp);
630
631 return 1;
586} 632}
587 633
588 634
589 635
590/***************************************************************************** 636/*****************************************************************************
591 * 637 *
592 * Code related to rods - perhaps better located in another file? 638 * Code related to rods - perhaps better located in another file?
593 * 639 *
594 ****************************************************************************/ 640 ****************************************************************************/
595 641
642void
596void regenerate_rod(object *rod) { 643regenerate_rod (object *rod)
644{
597 if (rod->stats.hp < rod->stats.maxhp) { 645 if (rod->stats.hp < rod->stats.maxhp)
646 {
598 rod->stats.hp+= 1 + rod->stats.maxhp/10; 647 rod->stats.hp += 1 + rod->stats.maxhp / 10;
599 648
600 if (rod->stats.hp > rod->stats.maxhp) 649 if (rod->stats.hp > rod->stats.maxhp)
601 rod->stats.hp = rod->stats.maxhp; 650 rod->stats.hp = rod->stats.maxhp;
602 } 651 }
603} 652}
604 653
605 654
655void
606void drain_rod_charge(object *rod) { 656drain_rod_charge (object *rod)
657{
607 rod->stats.hp -= SP_level_spellpoint_cost(rod, rod->inv, SPELL_HIGHEST); 658 rod->stats.hp -= SP_level_spellpoint_cost (rod, rod->inv, SPELL_HIGHEST);
608} 659}
609 660
610 661
611 662
612 663
… …
615 * op is what is looking for the target (which can be a player), 666 * 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 667 * dir is the direction we are looking in. Return object found, or
617 * NULL if no good object. 668 * NULL if no good object.
618 */ 669 */
619 670
671object *
620object *find_target_for_friendly_spell(object *op,int dir) { 672find_target_for_friendly_spell (object *op, int dir)
673{
621 object *tmp; 674 object *tmp;
622 mapstruct *m; 675 maptile *m;
623 sint16 x, y; 676 sint16 x, y;
624 int mflags; 677 int mflags;
625 678
626 /* I don't really get this block - if op isn't a player or rune, 679 /* 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. 680 * we then make the owner of this object the target.
628 * The owner could very well be no where near op. 681 * The owner could very well be no where near op.
629 */ 682 */
630 if(op->type!=PLAYER && op->type!=RUNE) { 683 if (op->type != PLAYER && op->type != RUNE)
631 tmp=get_owner(op); 684 {
685 tmp = op->owner;
632 /* If the owner does not exist, or is not a monster, than apply the spell 686 /* If the owner does not exist, or is not a monster, than apply the spell
633 * to the caster. 687 * to the caster.
634 */ 688 */
635 if(!tmp || !QUERY_FLAG(tmp,FLAG_MONSTER)) tmp=op; 689 if (!tmp || !QUERY_FLAG (tmp, FLAG_MONSTER))
690 tmp = op;
691 }
692 else
636 } 693 {
637 else {
638 m = op->map; 694 m = op->map;
639 x = op->x+freearr_x[dir]; 695 x = op->x + freearr_x[dir];
640 y = op->y+freearr_y[dir]; 696 y = op->y + freearr_y[dir];
641 697
642 mflags = get_map_flags(m, &m, x, y, &x, &y); 698 mflags = get_map_flags (m, &m, x, y, &x, &y);
643 699
644 if (mflags & P_OUT_OF_MAP) 700 if (mflags & P_OUT_OF_MAP)
645 tmp=NULL; 701 tmp = NULL;
646 else { 702 else
703 {
647 for(tmp=get_map_ob(m, x, y); tmp!=NULL; tmp=tmp->above) 704 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
648 if(tmp->type==PLAYER)
649 break;
650 }
651 }
652 /* didn't find a player there, look in current square for a player */
653 if(tmp==NULL)
654 for(tmp=get_map_ob(op->map,op->x,op->y);tmp!=NULL;tmp=tmp->above)
655 {
656 if(tmp->type==PLAYER) 705 if (tmp->type == PLAYER)
657 break; 706 break;
658 /* Don't forget to browse inside transports ! - gros 2006/07/25 */
659 if(tmp->type==TRANSPORT)
660 {
661 object* inv;
662 for (inv=tmp->inv; inv; inv=inv->below)
663 {
664 if ((inv->type == PLAYER) && (op == inv))
665 return inv;
666 }
667 } 707 }
708 }
709 /* didn't find a player there, look in current square for a player */
710 if (tmp == NULL)
711 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
712 {
713 if (tmp->type == PLAYER)
714 break;
668 } 715 }
669 716
670 return tmp; 717 return tmp;
671} 718}
672 719
673 720
674 721
675/* raytrace: 722/* raytrace:
… …
682 * It returns the direction toward the first/closest live object if it finds 729 * It returns the direction toward the first/closest live object if it finds
683 * any, otherwise -1. 730 * any, otherwise -1.
684 * note that exclude can be NULL, in which case all bets are off. 731 * note that exclude can be NULL, in which case all bets are off.
685 */ 732 */
686 733
734int
687int spell_find_dir(mapstruct *m, int x, int y, object *exclude) { 735spell_find_dir (maptile *m, int x, int y, object *exclude)
736{
688 int i,max=SIZEOFFREE; 737 int i, max = SIZEOFFREE;
689 sint16 nx,ny; 738 sint16 nx, ny;
690 int owner_type=0, mflags; 739 int owner_type = 0, mflags;
691 object *tmp; 740 object *tmp;
692 mapstruct *mp; 741 maptile *mp;
693 742
694 if (exclude && exclude->head) 743 if (exclude && exclude->head)
695 exclude = exclude->head; 744 exclude = exclude->head;
696 if (exclude && exclude->type) 745 if (exclude && exclude->type)
697 owner_type = exclude->type; 746 owner_type = exclude->type;
698 747
699 for(i=rndm(1, 8);i<max;i++) { 748 for (i = rndm (1, 8); i < max; i++)
749 {
700 nx = x + freearr_x[i]; 750 nx = x + freearr_x[i];
701 ny = y + freearr_y[i]; 751 ny = y + freearr_y[i];
702 mp = m; 752 mp = m;
703 mflags = get_map_flags(m, &mp, nx, ny, &nx, &ny); 753 mflags = get_map_flags (m, &mp, nx, ny, &nx, &ny);
704 if (mflags & (P_OUT_OF_MAP | P_BLOCKSVIEW)) continue; 754 if (mflags & (P_OUT_OF_MAP | P_BLOCKSVIEW))
755 continue;
705 756
706 tmp=get_map_ob(mp,nx,ny); 757 tmp = GET_MAP_OB (mp, nx, ny);
707 758
708 while(tmp!=NULL && (((owner_type==PLAYER && 759 while (tmp != NULL && (((owner_type == PLAYER &&
709 !QUERY_FLAG(tmp,FLAG_MONSTER) && !QUERY_FLAG(tmp,FLAG_GENERATOR)) || 760 !QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_GENERATOR)) ||
710 (owner_type!=PLAYER && tmp->type!=PLAYER)) || 761 (owner_type != PLAYER && tmp->type != PLAYER)) || (tmp == exclude || (tmp->head && tmp->head == exclude))))
711 (tmp == exclude || (tmp->head && tmp->head == exclude))))
712 tmp=tmp->above; 762 tmp = tmp->above;
713 763
714 if(tmp!=NULL && can_see_monsterP(m,x,y,i)) 764 if (tmp != NULL && can_see_monsterP (m, x, y, i))
715 return freedir[i]; 765 return freedir[i];
716 } 766 }
717 return -1; /* flag for "keep going the way you were" */ 767 return -1; /* flag for "keep going the way you were" */
718} 768}
719 769
720 770
721 771
722/* put_a_monster: puts a monster named monstername near by 772/* put_a_monster: puts a monster named monstername near by
723 * op. This creates the treasures for the monsters, and 773 * op. This creates the treasures for the monsters, and
724 * also deals with multipart monsters properly. 774 * also deals with multipart monsters properly.
725 */ 775 */
726 776
777void
727void put_a_monster(object *op,const char *monstername) { 778put_a_monster (object *op, const char *monstername)
779{
728 object *tmp,*head=NULL,*prev=NULL; 780 object *tmp, *head = NULL, *prev = NULL;
729 archetype *at; 781 archetype *at;
730 int dir; 782 int dir;
731 783
732 /* Handle cases where we are passed a bogus mosntername */ 784 /* Handle cases where we are passed a bogus mosntername */
733 785
734 if((at=find_archetype(monstername))==NULL) return; 786 if ((at = archetype::find (monstername)) == NULL)
787 return;
735 788
736 /* find a free square nearby 789 /* find a free square nearby
737 * first we check the closest square for free squares 790 * first we check the closest square for free squares
738 */ 791 */
739 792
740 dir=find_first_free_spot(&at->clone,op->map,op->x,op->y); 793 dir = find_first_free_spot (&at->clone, op->map, op->x, op->y);
741 if(dir!=-1) { 794 if (dir != -1)
795 {
742 /* This is basically grabbed for generate monster. Fixed 971225 to 796 /* This is basically grabbed for generate monster. Fixed 971225 to
743 * insert multipart monsters properly 797 * insert multipart monsters properly
744 */ 798 */
745 while (at!=NULL) { 799 while (at != NULL)
800 {
746 tmp=arch_to_object(at); 801 tmp = arch_to_object (at);
747 tmp->x=op->x+freearr_x[dir]+at->clone.x; 802 tmp->x = op->x + freearr_x[dir] + at->clone.x;
748 tmp->y=op->y+freearr_y[dir]+at->clone.y; 803 tmp->y = op->y + freearr_y[dir] + at->clone.y;
749 tmp->map = op->map; 804 tmp->map = op->map;
750 if (head) { 805 if (head)
751 tmp->head=head; 806 {
752 prev->more=tmp; 807 tmp->head = head;
753 } 808 prev->more = tmp;
754 if (!head) head=tmp; 809 }
755 prev=tmp; 810 if (!head)
811 head = tmp;
812 prev = tmp;
756 at=at->more; 813 at = at->more;
757 } 814 }
758 815
759 if (head->randomitems) 816 if (head->randomitems)
760 create_treasure(head->randomitems, head, GT_INVISIBLE, op->map->difficulty,0); 817 create_treasure (head->randomitems, head, GT_INVISIBLE, op->map->difficulty, 0);
761 818
762 insert_ob_in_map(head,op->map,op,0); 819 insert_ob_in_map (head, op->map, op, 0);
763 820
764 /* thought it'd be cool to insert a burnout, too.*/ 821 /* thought it'd be cool to insert a burnout, too. */
765 tmp=get_archetype("burnout"); 822 tmp = get_archetype ("burnout");
766 tmp->map = op->map; 823 tmp->map = op->map;
767 tmp->x=op->x+freearr_x[dir]; 824 tmp->x = op->x + freearr_x[dir];
768 tmp->y=op->y+freearr_y[dir]; 825 tmp->y = op->y + freearr_y[dir];
769 insert_ob_in_map(tmp,op->map,op,0); 826 insert_ob_in_map (tmp, op->map, op, 0);
770 } 827 }
771} 828}
772 829
773/* peterm: function which summons hostile monsters and 830/* peterm: function which summons hostile monsters and
774 * places them in nearby squares. 831 * places them in nearby squares.
… …
782 * use to call this, but best I can tell, that spell/ability was 839 * use to call this, but best I can tell, that spell/ability was
783 * never used. This is however used by various failures on the 840 * never used. This is however used by various failures on the
784 * players part (alchemy, reincarnation, etc) 841 * players part (alchemy, reincarnation, etc)
785 */ 842 */
786 843
844int
787int summon_hostile_monsters(object *op,int n,const char *monstername){ 845summon_hostile_monsters (object *op, int n, const char *monstername)
846{
788 int i; 847 int i;
848
789 for(i=0;i<n;i++) 849 for (i = 0; i < n; i++)
790 put_a_monster(op,monstername); 850 put_a_monster (op, monstername);
791 851
792 return n; 852 return n;
793} 853}
794 854
795 855
796/* Some local definitions for shuffle-attack */ 856/* Some local definitions for shuffle-attack */
797 struct attacktype_shuffle { 857struct attacktype_shuffle
858{
798 int attacktype; 859 int attacktype;
799 int face; 860 int face;
800 } ATTACKS[22] = { 861} ATTACKS[22] =
862{
863 {
801 {AT_PHYSICAL,0}, 864 AT_PHYSICAL, 0},
865 {
802 {AT_PHYSICAL,0}, /*face = explosion*/ 866 AT_PHYSICAL, 0}, /*face = explosion */
867 {
803 {AT_PHYSICAL,0}, 868 AT_PHYSICAL, 0},
869 {
804 {AT_MAGIC,1}, 870 AT_MAGIC, 1},
871 {
805 {AT_MAGIC,1}, /* face = last-burnout */ 872 AT_MAGIC, 1}, /* face = last-burnout */
873 {
806 {AT_MAGIC,1}, 874 AT_MAGIC, 1},
875 {
807 {AT_FIRE,2}, 876 AT_FIRE, 2},
877 {
808 {AT_FIRE,2}, /* face = fire.... */ 878 AT_FIRE, 2}, /* face = fire.... */
879 {
809 {AT_FIRE,2}, 880 AT_FIRE, 2},
881 {
810 {AT_ELECTRICITY,3}, 882 AT_ELECTRICITY, 3},
883 {
811 {AT_ELECTRICITY,3}, /* ball_lightning */ 884 AT_ELECTRICITY, 3}, /* ball_lightning */
885 {
812 {AT_ELECTRICITY,3}, 886 AT_ELECTRICITY, 3},
813 {AT_COLD,4}, 887 {
814 {AT_COLD,4}, /* face=icestorm*/
815 {AT_COLD,4}, 888 AT_COLD, 4},
889 {
890 AT_COLD, 4}, /* face=icestorm */
891 {
892 AT_COLD, 4},
893 {
816 {AT_CONFUSION,5}, 894 AT_CONFUSION, 5},
895 {
817 {AT_POISON,7}, 896 AT_POISON, 7},
897 {
818 {AT_POISON,7}, /* face = acid sphere. generator */ 898 AT_POISON, 7}, /* face = acid sphere. generator */
899 {
819 {AT_POISON,7}, /* poisoncloud face */ 900 AT_POISON, 7}, /* poisoncloud face */
901 {
820 {AT_SLOW,8}, 902 AT_SLOW, 8},
903 {
821 {AT_PARALYZE,9}, 904 AT_PARALYZE, 9},
905 {
822 {AT_FEAR,10} }; 906AT_FEAR, 10}};
823 907
824 908
825 909
826/* shuffle_attack: peterm 910/* shuffle_attack: peterm
827 * This routine shuffles the attack of op to one of the 911 * This routine shuffles the attack of op to one of the
… …
837 * would be nice. 921 * would be nice.
838 * I also fixed a bug here in that attacktype was |= - 922 * I also fixed a bug here in that attacktype was |= -
839 * to me, that would be that it would quickly get all 923 * to me, that would be that it would quickly get all
840 * attacktypes, which probably wasn't the intent. MSW 2003-06-03 924 * attacktypes, which probably wasn't the intent. MSW 2003-06-03
841 */ 925 */
926void
842void shuffle_attack(object *op,int change_face) 927shuffle_attack (object *op, int change_face)
843{ 928{
844 int i; 929 int i;
930
845 i=rndm(0, 21); 931 i = rndm (0, 21);
846 932
847 op->attacktype=ATTACKS[i].attacktype|AT_MAGIC; 933 op->attacktype = ATTACKS[i].attacktype | AT_MAGIC;
848 934
849 if(change_face) { 935 if (change_face)
936 {
850 SET_ANIMATION(op, ATTACKS[i].face); 937 SET_ANIMATION (op, ATTACKS[i].face);
851 } 938 }
852} 939}
853 940
854 941
855/* prayer_failure: This is called when a player fails 942/* prayer_failure: This is called when a player fails
… …
857 * op is the player. 944 * op is the player.
858 * failure is basically how much grace they had. 945 * failure is basically how much grace they had.
859 * power is how much grace the spell would normally take to cast. 946 * power is how much grace the spell would normally take to cast.
860 */ 947 */
861 948
949void
862void prayer_failure(object *op, int failure,int power) 950prayer_failure (object *op, int failure, int power)
863{ 951{
864 const char *godname; 952 const char *godname;
865 object *tmp; 953 object *tmp;
866 954
867 if(!strcmp((godname=determine_god(op)),"none")) godname="Your spirit"; 955 if (!strcmp ((godname = determine_god (op)), "none"))
956 godname = "Your spirit";
868 957
869 if(failure<= -20 && failure > -40) /* wonder */ 958 if (failure <= -20 && failure > -40) /* wonder */
870 { 959 {
871 new_draw_info_format(NDI_UNIQUE, 0,op,"%s gives a sign to renew your faith.",godname); 960 new_draw_info_format (NDI_UNIQUE, 0, op, "%s gives a sign to renew your faith.", godname);
872 tmp = get_archetype(SPELL_WONDER); 961 tmp = get_archetype (SPELL_WONDER);
873 cast_cone(op,op,0,tmp); 962 cast_cone (op, op, 0, tmp);
874 free_object(tmp); 963 tmp->destroy ();
875 } 964 }
876 965
877 else if (failure <= -40 && failure > -60) /* confusion */ 966 else if (failure <= -40 && failure > -60) /* confusion */
878 { 967 {
879 new_draw_info(NDI_UNIQUE, 0,op,"Your diety touches your mind!"); 968 new_draw_info (NDI_UNIQUE, 0, op, "Your diety touches your mind!");
880 confuse_player(op,op,99); 969 confuse_player (op, op, 99);
881 } 970 }
882 else if (failure <= -60 && failure> -150) /* paralysis */ 971 else if (failure <= -60 && failure > -150) /* paralysis */
883 { 972 {
884 new_draw_info_format(NDI_UNIQUE, 0,op,"%s requires you to pray NOW.",godname); 973 new_draw_info_format (NDI_UNIQUE, 0, op, "%s requires you to pray NOW.", godname);
885 new_draw_info(NDI_UNIQUE, 0,op,"You comply, ignoring all else."); 974 new_draw_info (NDI_UNIQUE, 0, op, "You comply, ignoring all else.");
886 paralyze_player(op,op,99); 975 paralyze_player (op, op, 99);
887 } 976 }
888 else if (failure <= -150) /* blast the immediate area */ 977 else if (failure <= -150) /* blast the immediate area */
889 { 978 {
890 tmp = get_archetype(GOD_POWER); 979 tmp = get_archetype (GOD_POWER);
891 new_draw_info_format(NDI_UNIQUE, 0,op,"%s smites you!",godname); 980 new_draw_info_format (NDI_UNIQUE, 0, op, "%s smites you!", godname);
892 cast_magic_storm(op,tmp, power); 981 cast_magic_storm (op, tmp, power);
893 } 982 }
894} 983}
895 984
896/* 985/*
897 * spell_failure() handles the various effects for differing degrees 986 * spell_failure() handles the various effects for differing degrees
… …
900 * failure is a random value of how badly you failed. 989 * failure is a random value of how badly you failed.
901 * power is how many spellpoints you'd normally need for the spell. 990 * power is how many spellpoints you'd normally need for the spell.
902 * skill is the skill you'd need to cast the spell. 991 * skill is the skill you'd need to cast the spell.
903 */ 992 */
904 993
994void
905void spell_failure(object *op, int failure,int power, object *skill) 995spell_failure (object *op, int failure, int power, object *skill)
906{ 996{
907 object *tmp; 997 object *tmp;
908 998
909 if (settings.spell_failure_effects == FALSE) 999 if (settings.spell_failure_effects == FALSE)
910 return; 1000 return;
911 1001
912 if (failure<=-20 && failure > -40) /* wonder */ 1002 if (failure <= -20 && failure > -40) /* wonder */
913 { 1003 {
914 new_draw_info(NDI_UNIQUE, 0,op,"Your spell causes an unexpected effect."); 1004 new_draw_info (NDI_UNIQUE, 0, op, "Your spell causes an unexpected effect.");
915 tmp = get_archetype(SPELL_WONDER); 1005 tmp = get_archetype (SPELL_WONDER);
916 cast_cone(op,op,0,tmp); 1006 cast_cone (op, op, 0, tmp);
917 free_object(tmp); 1007 tmp->destroy ();
918 } 1008 }
919 1009
920 else if (failure <= -40 && failure > -60) /* confusion */ 1010 else if (failure <= -40 && failure > -60) /* confusion */
921 { 1011 {
922 new_draw_info(NDI_UNIQUE, 0,op,"Your magic recoils on you, making you confused!"); 1012 new_draw_info (NDI_UNIQUE, 0, op, "Your magic recoils on you, making you confused!");
923 confuse_player(op,op,99); 1013 confuse_player (op, op, 99);
924 } 1014 }
925 else if (failure <= -60 && failure> -80) /* paralysis */ 1015 else if (failure <= -60 && failure > -80) /* paralysis */
926 { 1016 {
927 new_draw_info(NDI_UNIQUE, 0,op,"Your magic stuns you!"); 1017 new_draw_info (NDI_UNIQUE, 0, op, "Your magic stuns you!");
928 paralyze_player(op,op,99); 1018 paralyze_player (op, op, 99);
929 } 1019 }
930 else if (failure <= -80) /* blast the immediate area */ 1020 else if (failure <= -80) /* blast the immediate area */
931 { 1021 {
932 object *tmp; 1022 object *tmp;
1023
933 /* Safety check to make sure we don't get any mana storms in scorn */ 1024 /* Safety check to make sure we don't get any mana storms in scorn */
934 if (get_map_flags(op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC) { 1025 if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC)
1026 {
935 new_draw_info(NDI_UNIQUE, 0, op, "The magic warps and you are turned inside out!"); 1027 new_draw_info (NDI_UNIQUE, 0, op, "The magic warps and you are turned inside out!");
936 hit_player(op,9998,op,AT_INTERNAL,1); 1028 hit_player (op, 9998, op, AT_INTERNAL, 1);
937 1029
938 } else { 1030 }
1031 else
1032 {
939 new_draw_info(NDI_UNIQUE, 0,op,"You lose control of the mana! The uncontrolled magic blasts you!"); 1033 new_draw_info (NDI_UNIQUE, 0, op, "You lose control of the mana! The uncontrolled magic blasts you!");
940 tmp=get_archetype(LOOSE_MANA); 1034 tmp = get_archetype (LOOSE_MANA);
941 tmp->level=skill->level; 1035 tmp->level = skill->level;
942 tmp->x=op->x; 1036 tmp->x = op->x;
943 tmp->y=op->y; 1037 tmp->y = op->y;
944 1038
945 /* increase the area of destruction a little for more powerful spells */ 1039 /* increase the area of destruction a little for more powerful spells */
946 tmp->range+=isqrt(power); 1040 tmp->range += isqrt (power);
947 1041
948 if (power>25) tmp->stats.dam = 25 + isqrt(power); 1042 if (power > 25)
1043 tmp->stats.dam = 25 + isqrt (power);
1044 else
949 else tmp->stats.dam=power; /* nasty recoils! */ 1045 tmp->stats.dam = power; /* nasty recoils! */
950 1046
951 tmp->stats.maxhp=tmp->count; 1047 tmp->stats.maxhp = tmp->count;
952 insert_ob_in_map(tmp,op->map,NULL,0); 1048 insert_ob_in_map (tmp, op->map, NULL, 0);
953 } 1049 }
954 } 1050 }
955} 1051}
956 1052
1053int
957int cast_party_spell(object *op, object *caster,int dir,object *spell_ob, char *stringarg) 1054cast_party_spell (object *op, object *caster, int dir, object *spell_ob, char *stringarg)
958 { 1055{
959 int success; 1056 int success;
960 player *pl; 1057 player *pl;
961 object *spell; 1058 object *spell;
962 1059
963 if ( !spell_ob->other_arch ) 1060 if (!spell_ob->other_arch)
964 { 1061 {
965 LOG( llevError, "cast_party_spell: empty other arch\n" ); 1062 LOG (llevError, "cast_party_spell: empty other arch\n");
966 return 0; 1063 return 0;
967 } 1064 }
968 spell = arch_to_object( spell_ob->other_arch ); 1065 spell = arch_to_object (spell_ob->other_arch);
969 1066
970 /* Always cast spell on caster */ 1067 /* Always cast spell on caster */
971 success = cast_spell( op, caster, dir, spell, stringarg ); 1068 success = cast_spell (op, caster, dir, spell, stringarg);
972 1069
973 if ( caster->contr->party == NULL ) 1070 if (caster->contr->party == NULL)
974 { 1071 {
975 remove_ob( spell ); 1072 spell->remove ();
976 return success; 1073 return success;
977 } 1074 }
978 for( pl=first_player; pl!=NULL; pl=pl->next ) 1075 for (pl = first_player; pl != NULL; pl = pl->next)
979 if( ( pl->ob->contr->party == caster->contr->party ) && ( on_same_map( pl->ob, caster ) ) ) 1076 if ((pl->ob->contr->party == caster->contr->party) && (on_same_map (pl->ob, caster)))
980 { 1077 {
981 cast_spell( pl->ob, caster, pl->ob->facing, spell, stringarg ); 1078 cast_spell (pl->ob, caster, pl->ob->facing, spell, stringarg);
982 } 1079 }
983 remove_ob( spell ); 1080 spell->remove ();
984 return success; 1081 return success;
985 } 1082}
986 1083
987/* This is where the main dispatch when someone casts a spell. 1084/* This is where the main dispatch when someone casts a spell.
988 * 1085 *
989 * op is the creature that is owner of the object that is casting the spell - 1086 * op is the creature that is owner of the object that is casting the spell -
990 * eg, the player or monster. 1087 * eg, the player or monster.
… …
1010 * if it is a player casting the spell (op->type == PLAYER, op == caster), 1107 * if it is a player casting the spell (op->type == PLAYER, op == caster),
1011 * this function will decrease the mana/grace appropriately. For other 1108 * this function will decrease the mana/grace appropriately. For other
1012 * objects, the caller should do what it considers appropriate. 1109 * objects, the caller should do what it considers appropriate.
1013 */ 1110 */
1014 1111
1112int
1015int cast_spell(object *op, object *caster,int dir,object *spell_ob, char *stringarg) { 1113cast_spell (object *op, object *caster, int dir, object *spell_ob, char *stringarg)
1016 1114{
1017 const char *godname; 1115 const char *godname;
1018 int success=0,mflags, cast_level=0, old_shoottype; 1116 int success = 0, mflags, cast_level = 0, old_shoottype;
1019 object *skill=NULL; 1117 object *skill = NULL;
1020 1118
1021 old_shoottype = op->contr ? op->contr->shoottype : 0; 1119 old_shoottype = op->contr ? op->contr->shoottype : 0;
1022 1120
1023 if (!spell_ob) { 1121 if (!spell_ob)
1122 {
1024 LOG(llevError,"cast_spell: null spell object passed\n"); 1123 LOG (llevError, "cast_spell: null spell object passed\n");
1025 return 0; 1124 return 0;
1026 } 1125 }
1027 if(!strcmp((godname=determine_god(op)),"none")) godname="A random spirit";
1028 1126
1127 if (!strcmp ((godname = determine_god (op)), "none"))
1128 godname = "A random spirit";
1129
1029 /* the caller should set caster to op if appropriate */ 1130 /* the caller should set caster to op if appropriate */
1030 if (!caster) { 1131 if (!caster)
1132 {
1031 LOG(llevError,"cast_spell: null caster object passed\n"); 1133 LOG (llevError, "cast_spell: null caster object passed\n");
1032 return 0; 1134 return 0;
1033 } 1135 }
1034 1136
1035 /* if caster is a spell casting object, this normally shouldn't be 1137 /* if caster is a spell casting object, this normally shouldn't be
1036 * an issue, because they don't have any spellpaths set up. 1138 * an issue, because they don't have any spellpaths set up.
1037 */ 1139 */
1038 if (caster->path_denied & spell_ob->path_attuned) { 1140 if (caster->path_denied & spell_ob->path_attuned && !QUERY_FLAG (caster, FLAG_WIZCAST))
1141 {
1039 new_draw_info(NDI_UNIQUE, 0,op, "That spell path is denied to you."); 1142 new_draw_info (NDI_UNIQUE, 0, op, "That spell path is denied to you.");
1040 return 0; 1143 return 0;
1041 } 1144 }
1042 1145
1043 /* if it is a player casting the spell, and they are really casting it 1146 /* if it is a player casting the spell, and they are really casting it
1044 * (vs it coming from a wand, scroll, or whatever else), do some 1147 * (vs it coming from a wand, scroll, or whatever else), do some
1045 * checks. We let monsters do special things - eg, they 1148 * checks. We let monsters do special things - eg, they
1046 * don't need the skill, bypass level checks, etc. The monster function 1149 * don't need the skill, bypass level checks, etc. The monster function
1047 * should take care of that. 1150 * should take care of that.
1048 * Remove the wiz check here and move it further down - some spells 1151 * Remove the wiz check here and move it further down - some spells
1049 * need to have the right skill pointer passed, so we need to 1152 * need to have the right skill pointer passed, so we need to
1050 * at least process that code. 1153 * at least process that code.
1051 */ 1154 */
1052 if (op->type == PLAYER && op == caster) { 1155 if (op->type == PLAYER && op == caster)
1156 {
1053 cast_level = caster_level(caster, spell_ob); 1157 cast_level = caster_level (caster, spell_ob);
1054 if (spell_ob->skill) { 1158 if (spell_ob->skill)
1159 {
1055 skill = find_skill_by_name(op, spell_ob->skill); 1160 skill = find_skill_by_name (op, spell_ob->skill);
1056 if (!skill) { 1161 if (!skill)
1057 new_draw_info_format(NDI_UNIQUE, 0,op,"You need the skill %s to cast %s.",
1058 spell_ob->skill, spell_ob->name);
1059 return 0;
1060 }
1061 if (min_casting_level(op, spell_ob) > cast_level && !QUERY_FLAG(op, FLAG_WIZ)) {
1062 new_draw_info(NDI_UNIQUE, 0,op, "You lack enough skill to cast that spell.");
1063 return 0;
1064 }
1065 }
1066 /* If the caster is the wiz, they don't ever fail, and don't have
1067 * to have sufficient grace/mana.
1068 */
1069 if (!QUERY_FLAG(op, FLAG_WIZ)) {
1070 if (SP_level_spellpoint_cost(caster, spell_ob, SPELL_MANA) &&
1071 SP_level_spellpoint_cost(caster, spell_ob, SPELL_MANA) > op->stats.sp) {
1072 new_draw_info(NDI_UNIQUE, 0,op,"You don't have enough mana.");
1073 return 0;
1074 }
1075 if (SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE) &&
1076 SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE) > op->stats.grace) {
1077 if(random_roll(0, op->stats.Wis-1, op, PREFER_HIGH) + op->stats.grace -
1078 10*SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE)/op->stats.maxgrace >0) {
1079 new_draw_info_format(NDI_UNIQUE, 0,op,
1080 "%s grants your prayer, though you are unworthy.",godname);
1081 }
1082 else {
1083 prayer_failure(op,op->stats.grace,
1084 SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE) - op->stats.grace);
1085 new_draw_info_format(NDI_UNIQUE, 0,op,"%s ignores your prayer.",godname);
1086 return 0;
1087 }
1088 }
1089
1090 /* player/monster is trying to cast the spell. might fumble it */
1091 if (spell_ob->stats.grace && random_roll(0, 99, op, PREFER_HIGH) <
1092 (spell_ob->level/(float)MAX(1,op->level) *cleric_chance[op->stats.Wis])) {
1093 play_sound_player_only(op->contr, SOUND_FUMBLE_SPELL,0,0);
1094 new_draw_info(NDI_UNIQUE, 0,op,"You fumble the spell.");
1095 if (settings.casting_time == TRUE) {
1096 op->casting_time = -1;
1097 }
1098 op->stats.grace -= random_roll(1, SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE), op, PREFER_LOW);
1099 return 0;
1100 } else if (spell_ob->stats.sp) {
1101 int failure = random_roll(0, 199, op, PREFER_HIGH) -
1102 op->contr->encumbrance +op->level - spell_ob->level +35;
1103
1104 if( failure < 0) {
1105 new_draw_info(NDI_UNIQUE, 0,op,"You bungle the spell because you have too much heavy equipment in use.");
1106 if (settings.spell_failure_effects == TRUE)
1107 spell_failure(op,failure,
1108 SP_level_spellpoint_cost(caster,spell_ob, SPELL_MANA),
1109 skill);
1110 op->contr->shoottype = (rangetype) old_shoottype;
1111 op->stats.sp -= random_roll(0, SP_level_spellpoint_cost(caster,spell_ob, SPELL_MANA), op, PREFER_LOW);
1112 return 0;
1113 }
1114 }
1115 }
1116 }
1117
1118 mflags = get_map_flags(op->map, NULL, op->x, op->y, NULL, NULL);
1119
1120 /* See if we can cast a spell here. If the caster and op are
1121 * not alive, then this would mean that the mapmaker put the
1122 * objects on the space - presume that they know what they are
1123 * doing.
1124 */
1125 if (spell_ob->type == SPELL
1126 && (mflags & P_SAFE || caster->type != POTION) // elmex: prevent potions from casting on safe maps
1127 && !QUERY_FLAG(op, FLAG_WIZCAST)
1128 && (QUERY_FLAG(caster, FLAG_ALIVE)
1129 || QUERY_FLAG(op, FLAG_ALIVE))
1130 && (((mflags & P_NO_MAGIC) && spell_ob->stats.sp)
1131 || ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)))
1132 {
1133 if (op->type!=PLAYER)
1134 return 0;
1135
1136 if ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)
1137 new_draw_info_format(NDI_UNIQUE, 0,op,"This ground is unholy! %s ignores you.",godname);
1138 else if (mflags & P_SAFE)
1139 new_draw_info(NDI_UNIQUE, 0,op,
1140 "This ground is sacred! The gods prevent any magical effects done by you here!.");
1141 else
1142 switch(op->contr->shoottype)
1143 { 1162 {
1163 new_draw_info_format (NDI_UNIQUE, 0, op, "You need the skill %s to cast %s.", &spell_ob->skill, &spell_ob->name);
1164 return 0;
1165 }
1166 if (min_casting_level (op, spell_ob) > cast_level && !QUERY_FLAG (op, FLAG_WIZ))
1167 {
1168 new_draw_info (NDI_UNIQUE, 0, op, "You lack enough skill to cast that spell.");
1169 return 0;
1170 }
1171 }
1172 /* If the caster is the wiz, they don't ever fail, and don't have
1173 * to have sufficient grace/mana.
1174 */
1175 if (!QUERY_FLAG (op, FLAG_WIZ))
1176 {
1177 if (SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA) &&
1178 SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA) > op->stats.sp)
1179 {
1180 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough mana.");
1181 return 0;
1182 }
1183 if (SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) &&
1184 SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) > op->stats.grace)
1185 {
1186 if (random_roll (0, op->stats.Wis - 1, op, PREFER_HIGH) + op->stats.grace -
1187 10 * SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) / op->stats.maxgrace > 0)
1188 {
1189 new_draw_info_format (NDI_UNIQUE, 0, op, "%s grants your prayer, though you are unworthy.", godname);
1190 }
1191 else
1192 {
1193 prayer_failure (op, op->stats.grace, SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE) - op->stats.grace);
1194 new_draw_info_format (NDI_UNIQUE, 0, op, "%s ignores your prayer.", godname);
1195 return 0;
1196 }
1197 }
1198
1199 /* player/monster is trying to cast the spell. might fumble it */
1200 if (spell_ob->stats.grace && random_roll (0, 99, op, PREFER_HIGH) <
1201 (spell_ob->level / (float) MAX (1, op->level) * cleric_chance[op->stats.Wis]))
1202 {
1203 play_sound_player_only (op->contr, SOUND_FUMBLE_SPELL, 0, 0);
1204 new_draw_info (NDI_UNIQUE, 0, op, "You fumble the spell.");
1205 if (settings.casting_time == TRUE)
1206 {
1207 op->casting_time = -1;
1208 }
1209 op->stats.grace -= random_roll (1, SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE), op, PREFER_LOW);
1210 return 0;
1211 }
1212 else if (spell_ob->stats.sp)
1213 {
1214 int failure = random_roll (0, 199, op, PREFER_HIGH) - op->contr->encumbrance + op->level - spell_ob->level + 35;
1215
1216 if (failure < 0)
1217 {
1218 new_draw_info (NDI_UNIQUE, 0, op, "You bungle the spell because you have too much heavy equipment in use.");
1219 if (settings.spell_failure_effects == TRUE)
1220 spell_failure (op, failure, SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA), skill);
1221 op->contr->shoottype = (rangetype) old_shoottype;
1222 op->stats.sp -= random_roll (0, SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA), op, PREFER_LOW);
1223 return 0;
1224 }
1225 }
1226 }
1227 }
1228
1229 mflags = get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL);
1230
1231 /* See if we can cast a spell here. If the caster and op are
1232 * not alive, then this would mean that the mapmaker put the
1233 * objects on the space - presume that they know what they are
1234 * doing.
1235 */
1236
1237 if ((mflags & P_SAFE) && !QUERY_FLAG (op, FLAG_WIZCAST)) // There is _ABSOLUTELY_ no magic allowed here (except wizards :-)!
1238 {
1239 new_draw_info (NDI_UNIQUE, 0, op, "This ground is sacred! The gods prevent any magical effects done by you here!.");
1240 return 0;
1241 }
1242
1243 if ((spell_ob->type == SPELL)
1244 && (caster->type != POTION)
1245 && !QUERY_FLAG (op, FLAG_WIZCAST)
1246 && (QUERY_FLAG (caster, FLAG_ALIVE)
1247 || QUERY_FLAG (op, FLAG_ALIVE))
1248 && (((mflags & P_NO_MAGIC) && spell_ob->stats.sp) || ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)))
1249 {
1250 if (op->type != PLAYER)
1251 return 0;
1252
1253 if ((mflags & P_NO_CLERIC) && spell_ob->stats.grace)
1254 new_draw_info_format (NDI_UNIQUE, 0, op, "This ground is unholy! %s ignores you.", godname);
1255 else
1256 switch (op->contr->shoottype)
1257 {
1144 case range_magic: 1258 case range_magic:
1145 new_draw_info(NDI_UNIQUE, 0,op,"Something blocks your spellcasting."); 1259 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your spellcasting.");
1146 break; 1260 break;
1147 case range_misc: 1261 case range_misc:
1148 new_draw_info(NDI_UNIQUE, 0,op,"Something blocks the magic of your item."); 1262 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of your item.");
1149 break; 1263 break;
1150 case range_golem: 1264 case range_golem:
1151 new_draw_info(NDI_UNIQUE, 0,op,"Something blocks the magic of your scroll."); 1265 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of your scroll.");
1152 break; 1266 break;
1153 default: 1267 default:
1154 break; 1268 break;
1269 }
1270 return 0;
1271 }
1272
1273 if (caster == op && settings.casting_time == TRUE && spell_ob->type == SPELL)
1274 {
1275 if (op->casting_time == -1)
1276 { /* begin the casting */
1277 op->casting_time = (sint16) (spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob));
1278 op->spell = spell_ob;
1279 /* put the stringarg into the object struct so that when the
1280 * spell is actually cast, it knows about the stringarg.
1281 * necessary for the invoke command spells.
1282 */
1283 if (stringarg)
1284 {
1285 op->spellarg = strdup (stringarg);
1155 } 1286 }
1156 return 0; 1287 else
1288 op->spellarg = NULL;
1289 return 0;
1157 } 1290 }
1158 1291 else if (op->casting_time != 0)
1159 if (caster == op && settings.casting_time == TRUE && spell_ob->type == SPELL) { 1292 {
1160 if (op->casting_time==-1) { /* begin the casting */ 1293 if (op->type == PLAYER)
1161 op->casting_time = (sint16) (spell_ob->casting_time*PATH_TIME_MULT(op,spell_ob)); 1294 new_draw_info (NDI_UNIQUE, 0, op, "You are casting!");
1162 op->spell = spell_ob; 1295 return 0;
1163 /* put the stringarg into the object struct so that when the 1296 }
1164 * spell is actually cast, it knows about the stringarg. 1297 else
1165 * necessary for the invoke command spells. 1298 { /* casting_time == 0 */
1166 */ 1299 op->casting_time = -1;
1167 if(stringarg) { 1300 spell_ob = op->spell;
1168 op->spellarg = strdup_local(stringarg); 1301 stringarg = op->spellarg;
1302 }
1169 } 1303 }
1170 else op->spellarg=NULL; 1304 else
1171 return 0; 1305 {
1172 }
1173 else if (op->casting_time != 0) {
1174 if (op->type == PLAYER )
1175 new_draw_info(NDI_UNIQUE, 0,op,"You are casting!");
1176 return 0;
1177 } else { /* casting_time == 0 */
1178 op->casting_time = -1;
1179 spell_ob = op->spell;
1180 stringarg = op->spellarg;
1181 }
1182 } else {
1183 /* Take into account how long it takes to cast the spell. 1306 /* Take into account how long it takes to cast the spell.
1184 * if the player is casting it, then we use the time in 1307 * if the player is casting it, then we use the time in
1185 * the spell object. If it is a spell object, have it 1308 * the spell object. If it is a spell object, have it
1186 * take two ticks. Things that cast spells on the players 1309 * take two ticks. Things that cast spells on the players
1187 * behalf (eg, altars, and whatever else) shouldn't cost 1310 * behalf (eg, altars, and whatever else) shouldn't cost
1188 * the player any time. 1311 * the player any time.
1189 * Ignore casting time for firewalls 1312 * Ignore casting time for firewalls
1190 */ 1313 */
1191 if (caster == op && caster->type != FIREWALL) { 1314 if (caster == op && caster->type != FIREWALL)
1315 {
1192 op->speed_left -= spell_ob->casting_time*PATH_TIME_MULT(op,spell_ob) * FABS(op->speed); 1316 op->speed_left -= spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed);
1193 /* Other portions of the code may also decrement the speed of the player, so 1317 /* Other portions of the code may also decrement the speed of the player, so
1194 * put a lower limit so that the player isn't stuck here too long 1318 * put a lower limit so that the player isn't stuck here too long
1195 */ 1319 */
1196 if ((spell_ob->casting_time > 0) &&
1197 op->speed_left < -spell_ob->casting_time*PATH_TIME_MULT(op,spell_ob) * FABS(op->speed)) 1320 if ((spell_ob->casting_time > 0) && op->speed_left < -spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed))
1198 op->speed_left = -spell_ob->casting_time*PATH_TIME_MULT(op,spell_ob) * FABS(op->speed); 1321 op->speed_left = -spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed);
1199 } else if (caster->type == WAND || caster->type == HORN || 1322 }
1200 caster->type == ROD || caster->type == POTION || 1323 else if (caster->type == WAND || caster->type == HORN || caster->type == ROD || caster->type == POTION || caster->type == SCROLL)
1201 caster->type == SCROLL) { 1324 {
1202 op->speed_left -= 2 * FABS(op->speed); 1325 op->speed_left -= 2 * FABS (op->speed);
1203 } 1326 }
1204 } 1327 }
1205 1328
1206 if (op->type == PLAYER && op == caster) { 1329 if (op->type == PLAYER && op == caster)
1330 {
1207 op->stats.grace -= SP_level_spellpoint_cost(caster,spell_ob, SPELL_GRACE); 1331 op->stats.grace -= SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE);
1208 op->stats.sp -= SP_level_spellpoint_cost(caster,spell_ob, SPELL_MANA); 1332 op->stats.sp -= SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA);
1209 } 1333 }
1210 1334
1211 /* We want to try to find the skill to properly credit exp. 1335 /* We want to try to find the skill to properly credit exp.
1212 * for spell casting objects, the exp goes to the skill the casting 1336 * for spell casting objects, the exp goes to the skill the casting
1213 * object requires. 1337 * object requires.
1214 */ 1338 */
1215 if (op != caster && !skill && caster->skill) { 1339 if (op != caster && !skill && caster->skill)
1340 {
1216 skill = find_skill_by_name(op, caster->skill); 1341 skill = find_skill_by_name (op, caster->skill);
1217 if (!skill) { 1342 if (!skill)
1343 {
1218 new_draw_info_format(NDI_UNIQUE, 0,op,"You lack the skill %s to use the %s", 1344 new_draw_info_format (NDI_UNIQUE, 0, op, "You lack the skill %s to use the %s", &caster->skill, query_name (caster));
1219 caster->skill, query_name(caster));
1220 return 0; 1345 return 0;
1221 } 1346 }
1222 change_skill(op, skill, 0); /* needed for proper exp credit */ 1347 change_skill (op, skill, 0); /* needed for proper exp credit */
1223 } 1348 }
1224 1349
1225 switch(spell_ob->subtype) { 1350 switch (spell_ob->subtype)
1351 {
1226 /* The order of case statements is same as the order they show up 1352 /* The order of case statements is same as the order they show up
1227 * in in spells.h. 1353 * in in spells.h.
1228 */ 1354 */
1229 case SP_RAISE_DEAD: 1355 case SP_RAISE_DEAD:
1230 success = cast_raise_dead_spell(op,caster, spell_ob, dir,stringarg); 1356 success = cast_raise_dead_spell (op, caster, spell_ob, dir, stringarg);
1231 break; 1357 break;
1232 1358
1233 case SP_RUNE: 1359 case SP_RUNE:
1234 success = write_rune(op,caster, spell_ob, dir,stringarg); 1360 success = write_rune (op, caster, spell_ob, dir, stringarg);
1235 break; 1361 break;
1236 1362
1237 case SP_MAKE_MARK: 1363 case SP_MAKE_MARK:
1238 success = write_mark(op, spell_ob, stringarg); 1364 success = write_mark (op, spell_ob, stringarg);
1239 break; 1365 break;
1240 1366
1241 case SP_BOLT: 1367 case SP_BOLT:
1242 success = fire_bolt(op,caster,dir,spell_ob,skill); 1368 success = fire_bolt (op, caster, dir, spell_ob, skill);
1243 break; 1369 break;
1244 1370
1245 case SP_BULLET: 1371 case SP_BULLET:
1246 success = fire_bullet(op, caster, dir, spell_ob); 1372 success = fire_bullet (op, caster, dir, spell_ob);
1247 break; 1373 break;
1248 1374
1249 case SP_CONE: 1375 case SP_CONE:
1250 success = cast_cone(op, caster, dir, spell_ob); 1376 success = cast_cone (op, caster, dir, spell_ob);
1251 break; 1377 break;
1252 1378
1253 case SP_BOMB: 1379 case SP_BOMB:
1254 success = create_bomb(op,caster,dir, spell_ob); 1380 success = create_bomb (op, caster, dir, spell_ob);
1255 break; 1381 break;
1256 1382
1257 case SP_WONDER: 1383 case SP_WONDER:
1258 success = cast_wonder(op,caster, dir,spell_ob); 1384 success = cast_wonder (op, caster, dir, spell_ob);
1259 break; 1385 break;
1260 1386
1261 case SP_SMITE: 1387 case SP_SMITE:
1262 success = cast_smite_spell(op,caster, dir,spell_ob); 1388 success = cast_smite_spell (op, caster, dir, spell_ob);
1263 break; 1389 break;
1264 1390
1265 case SP_MAGIC_MISSILE: 1391 case SP_MAGIC_MISSILE:
1266 success = fire_arch_from_position(op, caster, op->x + freearr_x[dir], 1392 success = fire_arch_from_position (op, caster, op->x + freearr_x[dir], op->y + freearr_y[dir], dir, spell_ob);
1267 op->y + freearr_y[dir], dir, spell_ob);
1268 break; 1393 break;
1269 1394
1270 case SP_SUMMON_GOLEM: 1395 case SP_SUMMON_GOLEM:
1271 success = summon_golem(op, caster, dir, spell_ob); 1396 success = summon_golem (op, caster, dir, spell_ob);
1272 old_shoottype = range_golem; 1397 old_shoottype = range_golem;
1273 break; 1398 break;
1274 1399
1275 case SP_DIMENSION_DOOR: 1400 case SP_DIMENSION_DOOR:
1276 /* dimension door needs the actual caster, because that is what is 1401 /* dimension door needs the actual caster, because that is what is
1277 * moved. 1402 * moved.
1278 */ 1403 */
1279 success = dimension_door(op,caster, spell_ob, dir); 1404 success = dimension_door (op, caster, spell_ob, dir);
1280 break; 1405 break;
1281 1406
1282 case SP_MAGIC_MAPPING: 1407 case SP_MAGIC_MAPPING:
1283 if(op->type==PLAYER) { 1408 if (op->type == PLAYER)
1409 {
1284 spell_effect(spell_ob, op->x, op->y, op->map, op); 1410 spell_effect (spell_ob, op->x, op->y, op->map, op);
1285 draw_magic_map(op); 1411 draw_magic_map (op);
1286 success=1; 1412 success = 1;
1287 } 1413 }
1288 else success=0; 1414 else
1415 success = 0;
1289 break; 1416 break;
1290 1417
1291 case SP_MAGIC_WALL: 1418 case SP_MAGIC_WALL:
1292 success = magic_wall(op,caster,dir,spell_ob); 1419 success = magic_wall (op, caster, dir, spell_ob);
1293 break; 1420 break;
1294 1421
1295 case SP_DESTRUCTION: 1422 case SP_DESTRUCTION:
1296 success = cast_destruction(op,caster,spell_ob); 1423 success = cast_destruction (op, caster, spell_ob);
1297 break; 1424 break;
1298 1425
1299 case SP_PERCEIVE_SELF: 1426 case SP_PERCEIVE_SELF:
1300 success = perceive_self(op); 1427 success = perceive_self (op);
1301 break; 1428 break;
1302 1429
1303 case SP_WORD_OF_RECALL: 1430 case SP_WORD_OF_RECALL:
1304 success = cast_word_of_recall(op,caster,spell_ob); 1431 success = cast_word_of_recall (op, caster, spell_ob);
1305 break; 1432 break;
1306 1433
1307 case SP_INVISIBLE: 1434 case SP_INVISIBLE:
1308 success = cast_invisible(op,caster,spell_ob); 1435 success = cast_invisible (op, caster, spell_ob);
1309 break; 1436 break;
1310 1437
1311 case SP_PROBE: 1438 case SP_PROBE:
1312 success = probe(op,caster, spell_ob, dir); 1439 success = probe (op, caster, spell_ob, dir);
1313 break; 1440 break;
1314 1441
1315 case SP_HEALING: 1442 case SP_HEALING:
1316 success = cast_heal(op,caster, spell_ob, dir); 1443 success = cast_heal (op, caster, spell_ob, dir);
1317 break; 1444 break;
1318 1445
1319 case SP_CREATE_FOOD: 1446 case SP_CREATE_FOOD:
1320 success = cast_create_food(op,caster,spell_ob, dir,stringarg); 1447 success = cast_create_food (op, caster, spell_ob, dir, stringarg);
1321 break; 1448 break;
1322 1449
1323 case SP_EARTH_TO_DUST: 1450 case SP_EARTH_TO_DUST:
1324 success = cast_earth_to_dust(op,caster,spell_ob); 1451 success = cast_earth_to_dust (op, caster, spell_ob);
1325 break; 1452 break;
1326 1453
1327 case SP_CHANGE_ABILITY: 1454 case SP_CHANGE_ABILITY:
1328 success = cast_change_ability(op,caster,spell_ob, dir, 0); 1455 success = cast_change_ability (op, caster, spell_ob, dir, 0);
1329 break; 1456 break;
1330 1457
1331 case SP_BLESS: 1458 case SP_BLESS:
1332 success = cast_bless(op,caster,spell_ob, dir); 1459 success = cast_bless (op, caster, spell_ob, dir);
1333 break; 1460 break;
1334 1461
1335 case SP_CURSE: 1462 case SP_CURSE:
1336 success = cast_curse(op,caster,spell_ob, dir); 1463 success = cast_curse (op, caster, spell_ob, dir);
1337 break; 1464 break;
1338 1465
1339 case SP_SUMMON_MONSTER: 1466 case SP_SUMMON_MONSTER:
1340 success = summon_object(op,caster,spell_ob, dir,stringarg); 1467 success = summon_object (op, caster, spell_ob, dir, stringarg);
1341 break; 1468 break;
1342 1469
1343 case SP_CHARGING: 1470 case SP_CHARGING:
1344 success = recharge(op, caster, spell_ob); 1471 success = recharge (op, caster, spell_ob);
1345 break; 1472 break;
1346 1473
1347 case SP_POLYMORPH: 1474 case SP_POLYMORPH:
1348#ifdef NO_POLYMORPH 1475#ifdef NO_POLYMORPH
1349 /* Not great, but at least provide feedback so if players do have 1476 /* Not great, but at least provide feedback so if players do have
1350 * polymorph (ie, find it as a preset item or left over from before 1477 * polymorph (ie, find it as a preset item or left over from before
1351 * it was disabled), they get some feedback. 1478 * it was disabled), they get some feedback.
1352 */ 1479 */
1353 new_draw_info(NDI_UNIQUE, 0,op,"The spell fizzles"); 1480 new_draw_info (NDI_UNIQUE, 0, op, "The spell fizzles");
1354 success = 0; 1481 success = 0;
1355#else 1482#else
1356 success = cast_polymorph(op,caster,spell_ob, dir); 1483 success = cast_polymorph (op, caster, spell_ob, dir);
1357#endif 1484#endif
1358 break; 1485 break;
1359 1486
1360 case SP_ALCHEMY: 1487 case SP_ALCHEMY:
1361 success = alchemy(op, caster, spell_ob); 1488 success = alchemy (op, caster, spell_ob);
1362 break; 1489 break;
1363 1490
1364 case SP_REMOVE_CURSE: 1491 case SP_REMOVE_CURSE:
1365 success = remove_curse(op, caster, spell_ob); 1492 success = remove_curse (op, caster, spell_ob);
1366 break; 1493 break;
1367 1494
1368 case SP_IDENTIFY: 1495 case SP_IDENTIFY:
1369 success = cast_identify(op, caster, spell_ob); 1496 success = cast_identify (op, caster, spell_ob);
1370 break; 1497 break;
1371 1498
1372 case SP_DETECTION: 1499 case SP_DETECTION:
1373 success = cast_detection(op, caster, spell_ob, skill); 1500 success = cast_detection (op, caster, spell_ob, skill);
1374 break; 1501 break;
1375 1502
1376 case SP_MOOD_CHANGE: 1503 case SP_MOOD_CHANGE:
1377 success = mood_change(op, caster, spell_ob); 1504 success = mood_change (op, caster, spell_ob);
1378 break; 1505 break;
1379 1506
1380 case SP_MOVING_BALL: 1507 case SP_MOVING_BALL:
1381 if (spell_ob->path_repelled &&
1382 (spell_ob->path_repelled & caster->path_attuned) != spell_ob->path_repelled) { 1508 if (spell_ob->path_repelled && (spell_ob->path_repelled & caster->path_attuned) != spell_ob->path_repelled)
1383 new_draw_info_format(NDI_UNIQUE, 0, op, 1509 {
1384 "You lack the proper attunement to cast %s", spell_ob->name); 1510 new_draw_info_format (NDI_UNIQUE, 0, op, "You lack the proper attunement to cast %s", &spell_ob->name);
1385 success = 0; 1511 success = 0;
1386 } else 1512 }
1387 success = fire_arch_from_position(op,caster, 1513 else
1388 op->x + freearr_x[dir], op->y + freearr_y[dir], 1514 success = fire_arch_from_position (op, caster, op->x + freearr_x[dir], op->y + freearr_y[dir], dir, spell_ob);
1389 dir, spell_ob);
1390 break; 1515 break;
1391 1516
1392 case SP_SWARM: 1517 case SP_SWARM:
1393 success = fire_swarm(op, caster, spell_ob, dir); 1518 success = fire_swarm (op, caster, spell_ob, dir);
1394 break; 1519 break;
1395 1520
1396 case SP_CHANGE_MANA: 1521 case SP_CHANGE_MANA:
1397 success = cast_transfer(op,caster, spell_ob, dir); 1522 success = cast_transfer (op, caster, spell_ob, dir);
1398 break; 1523 break;
1399 1524
1400 case SP_DISPEL_RUNE: 1525 case SP_DISPEL_RUNE:
1401 /* in rune.c */ 1526 /* in rune.c */
1402 success = dispel_rune(op,caster, spell_ob, skill, dir); 1527 success = dispel_rune (op, caster, spell_ob, skill, dir);
1403 break; 1528 break;
1404 1529
1405 case SP_CREATE_MISSILE: 1530 case SP_CREATE_MISSILE:
1406 success = cast_create_missile(op,caster,spell_ob, dir,stringarg); 1531 success = cast_create_missile (op, caster, spell_ob, dir, stringarg);
1407 break; 1532 break;
1408 1533
1409 case SP_CONSECRATE: 1534 case SP_CONSECRATE:
1410 success = cast_consecrate(op, caster, spell_ob); 1535 success = cast_consecrate (op, caster, spell_ob);
1411 break; 1536 break;
1412 1537
1413 case SP_ANIMATE_WEAPON: 1538 case SP_ANIMATE_WEAPON:
1414 success = animate_weapon(op, caster, spell_ob, dir); 1539 success = animate_weapon (op, caster, spell_ob, dir);
1415 old_shoottype = range_golem; 1540 old_shoottype = range_golem;
1416 break; 1541 break;
1417 1542
1418 case SP_LIGHT: 1543 case SP_LIGHT:
1419 success = cast_light(op, caster, spell_ob, dir); 1544 success = cast_light (op, caster, spell_ob, dir);
1420 break; 1545 break;
1421 1546
1422 case SP_CHANGE_MAP_LIGHT: 1547 case SP_CHANGE_MAP_LIGHT:
1423 success = cast_change_map_lightlevel(op, caster, spell_ob); 1548 success = cast_change_map_lightlevel (op, caster, spell_ob);
1424 break; 1549 break;
1425 1550
1426 case SP_FAERY_FIRE: 1551 case SP_FAERY_FIRE:
1427 success = cast_destruction(op,caster,spell_ob); 1552 success = cast_destruction (op, caster, spell_ob);
1428 break; 1553 break;
1429 1554
1430 case SP_CAUSE_DISEASE: 1555 case SP_CAUSE_DISEASE:
1431 success = cast_cause_disease(op, caster, spell_ob, dir); 1556 success = cast_cause_disease (op, caster, spell_ob, dir);
1432 break; 1557 break;
1433 1558
1434 case SP_AURA: 1559 case SP_AURA:
1435 success = create_aura(op, caster, spell_ob); 1560 success = create_aura (op, caster, spell_ob);
1436 break; 1561 break;
1437 1562
1438 case SP_TOWN_PORTAL: 1563 case SP_TOWN_PORTAL:
1439 success= cast_create_town_portal (op,caster,spell_ob, dir); 1564 success = cast_create_town_portal (op, caster, spell_ob, dir);
1440 break; 1565 break;
1441 1566
1442 case SP_PARTY_SPELL: 1567 case SP_PARTY_SPELL:
1443 success = cast_party_spell (op, caster, dir, spell_ob, stringarg); 1568 success = cast_party_spell (op, caster, dir, spell_ob, stringarg);
1444 break; 1569 break;
1445 1570
1446 case SP_PERL: 1571 default:
1447 INVOKE_OBJECT (CAST_SPELL, op, ARG_OBJECT (caster), ARG_OBJECT (spell_ob), ARG_STRING (stringarg)); 1572 if (!INVOKE_OBJECT (CAST_SPELL, spell_ob, ARG_OBJECT (op), ARG_OBJECT (caster), ARG_INT (dir), ARG_STRING (stringarg)))
1448 break;
1449
1450 default:
1451 LOG(llevError,"cast_spell: Unhandled spell subtype %d\n", 1573 LOG (llevError, "cast_spell: Unhandled spell subtype %d\n", spell_ob->subtype);
1452 spell_ob->subtype);
1453
1454
1455 } 1574 }
1456 1575
1457 /* FIXME - we need some better sound suppport */ 1576 /* FIXME - we need some better sound suppport */
1458 // yes, for example, augment map info with the spell effect 1577 // yes, for example, augment map info with the spell effect
1459 // so clients can calculate the sounds themselves 1578 // so clients can calculate the sounds themselves
1460 //play_sound_map(op->map, op->x, op->y, SOUND_CAST_SPELL_0 + spell_ob->subtype); 1579 //play_sound_map(op->map, op->x, op->y, SOUND_CAST_SPELL_0 + spell_ob->subtype);
1461 1580
1462 /* free the spell arg */ 1581 /* free the spell arg */
1463 if(settings.casting_time == TRUE && stringarg) { 1582 if (settings.casting_time == TRUE && stringarg)
1464 free(stringarg);
1465 stringarg=NULL;
1466 } 1583 {
1584 free (stringarg);
1585 stringarg = NULL;
1586 }
1467 /* perhaps a bit of a hack, but if using a wand, it has to change the skill 1587 /* perhaps a bit of a hack, but if using a wand, it has to change the skill
1468 * to something like use_magic_item, but you really want to be able to fire 1588 * to something like use_magic_item, but you really want to be able to fire
1469 * it again. 1589 * it again.
1470 */ 1590 */
1591 if (op->contr)
1471 if (op->contr) op->contr->shoottype = (rangetype) old_shoottype; 1592 op->contr->shoottype = (rangetype) old_shoottype;
1472 1593
1473 return success; 1594 return success;
1474} 1595}
1475 1596
1476 1597
1477/* This is called from time.c/process_object(). That function 1598/* This is called from time.c/process_object(). That function
1478 * calls this for any SPELL_EFFECT type objects. This function 1599 * calls this for any SPELL_EFFECT type objects. This function
1479 * then dispatches them to the appropriate specific routines. 1600 * then dispatches them to the appropriate specific routines.
1480 */ 1601 */
1602void
1481void move_spell_effect(object *op) { 1603move_spell_effect (object *op)
1482 1604{
1483 switch (op->subtype) { 1605 switch (op->subtype)
1606 {
1484 case SP_BOLT: 1607 case SP_BOLT:
1485 move_bolt(op); 1608 move_bolt (op);
1486 break; 1609 break;
1487 1610
1488 case SP_BULLET: 1611 case SP_BULLET:
1489 move_bullet(op); 1612 move_bullet (op);
1490 break; 1613 break;
1491 1614
1492 case SP_EXPLOSION: 1615 case SP_EXPLOSION:
1493 explosion(op); 1616 explosion (op);
1494 break; 1617 break;
1495 1618
1496 case SP_CONE: 1619 case SP_CONE:
1497 move_cone(op); 1620 move_cone (op);
1498 break; 1621 break;
1499 1622
1500 case SP_BOMB: 1623 case SP_BOMB:
1501 animate_bomb(op); 1624 animate_bomb (op);
1502 break; 1625 break;
1503 1626
1504 case SP_MAGIC_MISSILE: 1627 case SP_MAGIC_MISSILE:
1505 move_missile(op); 1628 move_missile (op);
1506 break; 1629 break;
1507 1630
1508 case SP_WORD_OF_RECALL: 1631 case SP_WORD_OF_RECALL:
1509 execute_word_of_recall(op); 1632 execute_word_of_recall (op);
1510 break; 1633 break;
1511 1634
1512 case SP_MOVING_BALL: 1635 case SP_MOVING_BALL:
1513 move_ball_spell(op); 1636 move_ball_spell (op);
1514 break; 1637 break;
1515 1638
1516 case SP_SWARM: 1639 case SP_SWARM:
1517 move_swarm_spell(op); 1640 move_swarm_spell (op);
1518 break; 1641 break;
1519 1642
1520 case SP_AURA: 1643 case SP_AURA:
1521 move_aura(op); 1644 move_aura (op);
1522 break; 1645 break;
1523
1524 } 1646 }
1525} 1647}
1526 1648
1527/* this checks to see if something special should happen if 1649/* this checks to see if something special should happen if
1528 * something runs into the object. 1650 * something runs into the object.
1529 */ 1651 */
1652void
1530void check_spell_effect(object *op) { 1653check_spell_effect (object *op)
1531 1654{
1532 switch (op->subtype) { 1655 switch (op->subtype)
1656 {
1533 case SP_BOLT: 1657 case SP_BOLT:
1534 move_bolt(op); 1658 move_bolt (op);
1535 return; 1659 return;
1536 1660
1537 case SP_BULLET: 1661 case SP_BULLET:
1538 check_bullet(op); 1662 check_bullet (op);
1539 return; 1663 return;
1540 } 1664 }
1541
1542} 1665}
1543 1666
1544/* This is called by move_apply. Basically, if someone 1667/* This is called by move_apply. Basically, if someone
1545 * moves onto a spell effect and the walk_on or fly_on flags 1668 * moves onto a spell effect and the walk_on or fly_on flags
1546 * are set, this is called. This should only be called for 1669 * are set, this is called. This should only be called for
1547 * objects of the appropraite type. 1670 * objects of the appropraite type.
1548 */ 1671 */
1672void
1549void apply_spell_effect(object *spell, object *victim) 1673apply_spell_effect (object *spell, object *victim)
1550{ 1674{
1551 switch (spell->subtype) { 1675 switch (spell->subtype)
1676 {
1552 case SP_CONE: 1677 case SP_CONE:
1553 if (QUERY_FLAG(victim, FLAG_ALIVE) && spell->speed && spell->attacktype) 1678 if (QUERY_FLAG (victim, FLAG_ALIVE) && spell->speed && spell->attacktype)
1554 hit_player(victim, spell->stats.dam, spell, spell->attacktype, 0); 1679 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 0);
1555 break; 1680 break;
1556 1681
1557 case SP_MAGIC_MISSILE: 1682 case SP_MAGIC_MISSILE:
1558 if (QUERY_FLAG (victim, FLAG_ALIVE)) {
1559 tag_t spell_tag = spell->count;
1560 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
1561 if ( ! was_destroyed (spell, spell_tag)) {
1562 remove_ob (spell);
1563 free_object (spell);
1564 }
1565 }
1566 break;
1567
1568 case SP_MOVING_BALL:
1569 if (QUERY_FLAG (victim, FLAG_ALIVE)) 1683 if (QUERY_FLAG (victim, FLAG_ALIVE))
1684 {
1685 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
1686
1687 if (!spell->destroyed ())
1688 spell->destroy ();
1689 }
1690 break;
1691
1692 case SP_MOVING_BALL:
1693 if (QUERY_FLAG (victim, FLAG_ALIVE))
1570 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1); 1694 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
1571 else if (victim->material || victim->materialname) 1695 else if (victim->material || victim->materialname)
1572 save_throw_object (victim, spell->attacktype, spell); 1696 save_throw_object (victim, spell->attacktype, spell);
1573 break; 1697 break;
1574 } 1698 }
1575} 1699}

Diff Legend

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