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.5 by root, Tue Aug 29 08:01:38 2006 UTC vs.
Revision 1.16 by root, Tue Dec 12 20:53:03 2006 UTC

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

Diff Legend

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