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

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.3 by root, Sat Aug 26 23:36:34 2006 UTC vs.
Revision 1.28 by root, Sat Dec 30 10:16:11 2006 UTC

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

Diff Legend

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