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

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.6 by elmex, Tue Aug 29 11:58:02 2006 UTC vs.
Revision 1.12 by root, Thu Sep 14 23:13:49 2006 UTC

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

Diff Legend

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