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

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.3 by root, Sat Aug 26 23:36:34 2006 UTC vs.
Revision 1.107 by elmex, Thu Sep 17 16:53:15 2009 UTC

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

Diff Legend

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