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

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.6 by elmex, Tue Aug 29 11:58:02 2006 UTC vs.
Revision 1.31 by root, Thu Jan 4 16:19:32 2007 UTC

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

Diff Legend

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