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

Diff Legend

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