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.6 by elmex, Tue Aug 29 11:58:02 2006 UTC vs.
Revision 1.33 by root, Sun Jan 7 02:39:14 2007 UTC

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

Diff Legend

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