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

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.5 by root, Tue Aug 29 08:01:38 2006 UTC vs.
Revision 1.25 by root, Sat Dec 23 09:58:23 2006 UTC

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

Diff Legend

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