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.3 by root, Sat Aug 26 23:36:34 2006 UTC vs.
Revision 1.20 by root, Thu Dec 14 04:30:32 2006 UTC

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

Diff Legend

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