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.1 by elmex, Sun Aug 13 17:16:05 2006 UTC vs.
Revision 1.17 by root, Sat Sep 16 22:24:13 2006 UTC

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

Diff Legend

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