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

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.7 by root, Sun Sep 3 00:18:42 2006 UTC vs.
Revision 1.8 by root, Sun Sep 10 15:59:57 2006 UTC

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

Diff Legend

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