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

Comparing deliantra/server/server/rune.C (file contents):
Revision 1.2 by root, Tue Aug 29 08:01:38 2006 UTC vs.
Revision 1.39 by root, Sun Jan 4 22:39:59 2009 UTC

1/* 1/*
2 * static char *rcsid_rune_c = 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * "$Id: rune.C,v 1.2 2006/08/29 08:01:38 root Exp $"; 3 *
4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2003,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 23
6/*
7 CrossFire, A Multiplayer game for X-windows
8
9 Copyright (C) 2003 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen
11
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25
26 The authors can be reached via e-mail at crossfire-devel@real-time.com
27*/
28
29#include <global.h> 24#include <global.h>
30#ifndef __CEXTRACT__
31#include <sproto.h> 25#include <sproto.h>
26#include <spells.h>
27
28#ifndef sqr
29# define sqr(x) ((x)*(x))
32#endif 30#endif
33#include <spells.h>
34
35
36#ifndef sqr
37#define sqr(x) ((x)*(x))
38#endif
39
40 31
41/* peterm: 32/* peterm:
42 * write_rune: 33 * write_rune:
43 * op: rune writer 34 * op: rune writer
44 * skop: skill object used for casting this rune 35 * skop: skill object used for casting this rune
45 * dir: orientation of rune, direction rune's contained spell will 36 * dir: orientation of rune, direction rune's contained spell will
46 * be cast in, if applicable 37 * be cast in, if applicable
47 * inspell: spell object to put into the rune, can be null if doing 38 * spell: spell object to put into the rune
48 * a marking rune.
49 * level: level of casting of the rune 39 * level: level of casting of the rune
50 * runename: name of the rune or message displayed by the rune for 40 * runename: name of the rune or message displayed by the rune for
51 * a rune of marking 41 * a rune of marking
52 */ 42 */
53 43int
54int write_rune(object *op,object *caster, object *spell, int dir, const char *runename) { 44write_rune (object *op, object *caster, object *spell, int dir, const char *runename)
45{
55 object *tmp, *rune_spell, *rune; 46 object *tmp, *rune_spell, *rune;
56 char buf[MAX_BUF]; 47 maptile *m;
57 mapstruct *m;
58 sint16 nx,ny; 48 sint16 nx, ny;
59 49
60 if(!dir) { 50 if (!dir)
61 dir=1; 51 dir = 1;
62 }
63 52
64 nx=op->x+freearr_x[dir]; 53 nx = op->x + freearr_x[dir];
65 ny=op->y+freearr_y[dir]; 54 ny = op->y + freearr_y[dir];
66 m = op->map; 55 m = op->map;
67 56
68 if (get_map_flags(m, &m, nx, ny, &nx, &ny)) { 57 if (get_map_flags (m, &m, nx, ny, &nx, &ny) & (P_OUT_OF_MAP | P_SAFE | P_NO_MAGIC | P_NO_CLERIC))
58 {
69 new_draw_info(NDI_UNIQUE, 0,op,"Can't make a rune there!"); 59 new_draw_info (NDI_UNIQUE, 0, op, "Can't make a rune there!");
70 return 0;
71 }
72 for(tmp=get_map_ob(m,nx,ny);tmp!=NULL;tmp=tmp->above)
73 if(tmp->type==RUNE) break;
74
75 if(tmp){
76 new_draw_info(NDI_UNIQUE, 0,op,"You can't write a rune there.");
77 return 0; 60 return 0;
78 } 61 }
79 62
63 for (tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)
64 if (tmp->type == RUNE)
65 break;
66
67 if (tmp)
68 {
69 new_draw_info (NDI_UNIQUE, 0, op, "You can't write a rune on top of another rune.");
70 return 0;
71 }
72
80 if (spell->other_arch) { 73 if (spell->other_arch)
81 rune_spell = arch_to_object(spell->other_arch); 74 rune_spell = arch_to_object (spell->other_arch);
82 } else { 75 else
76 {
83 /* Player specified spell. The player has to know the spell, so 77 /* Player specified spell. The player has to know the spell, so
84 * lets just look through the players inventory see if they know it 78 * lets just look through the players inventory see if they know it
85 * use the item_matched_string for our typical matching method. 79 * use the item_matched_string for our typical matching method.
86 */ 80 */
87 int bestmatch = 0, ms; 81 int bestmatch = 0, ms;
88 82
89 if (!runename || *runename == 0) { 83 if (!runename || *runename == 0)
84 {
90 new_draw_info(NDI_UNIQUE, 0, op, "Write a rune of what?"); 85 new_draw_info (NDI_UNIQUE, 0, op, "Write a rune of what?");
91 return 0; 86 return 0;
92 } 87 }
93 88
94 rune_spell=NULL; 89 rune_spell = NULL;
95 for (tmp=op->inv; tmp; tmp=tmp->below) { 90 for (tmp = op->inv; tmp; tmp = tmp->below)
96 if (tmp->type == SPELL) { 91 if (tmp->type == SPELL)
92 {
97 ms = item_matched_string(op, tmp, runename); 93 ms = item_matched_string (op, tmp, runename);
98 if (ms > bestmatch) { 94 if (ms > bestmatch)
95 {
99 bestmatch = ms; 96 bestmatch = ms;
100 rune_spell = tmp; 97 rune_spell = tmp;
101 } 98 }
102 } 99 }
103 } 100
104 if (!rune_spell) { 101 if (!rune_spell)
102 {
105 new_draw_info_format(NDI_UNIQUE, 0, op, "You don't know any spell named %s", 103 new_draw_info_format (NDI_UNIQUE, 0, op, "You don't know any spell named %s.", runename);
106 runename);
107 return 0; 104 return 0;
108 } 105 }
106
109 if (rune_spell->skill != spell->skill) { 107 if (rune_spell->skill != spell->skill)
110 new_draw_info_format(NDI_UNIQUE, 0, op, "You can't cast %s with %s", 108 {
111 rune_spell->name, spell->name); 109 new_draw_info_format (NDI_UNIQUE, 0, op, "You can't cast %s with %s. H<The spell must be of the %s spell school.>", &rune_spell->name, &spell->name, &spell->skill);
112 return 0; 110 return 0;
111 }
112
113 if (caster->path_denied & spell->path_attuned && !caster->flag [FLAG_WIZCAST])
113 } 114 {
114 if (caster->path_denied & spell->path_attuned) {
115 new_draw_info_format(NDI_UNIQUE, 0,op, "%s belongs to a spell path denied to you.", 115 new_draw_info_format (NDI_UNIQUE, 0, op, "%s belongs to a spell path denied to you.", &rune_spell->name);
116 rune_spell->name);
117 return 0; 116 return 0;
117 }
118
119 if (casting_level (caster, rune_spell) < rune_spell->level && !caster->flag [FLAG_WIZCAST])
118 } 120 {
119 if (caster_level(caster, rune_spell) < rune_spell->level) { 121 new_draw_info_format (NDI_UNIQUE, 0, op, "%s is beyond your ability to cast! H<Your effetcive casting level is too low.>", &rune_spell->name);
120 new_draw_info_format(NDI_UNIQUE, 0,op, "%s is beyond your ability to cast!",
121 rune_spell->name);
122 return 0; 122 return 0;
123 } 123 }
124
124 if (SP_level_spellpoint_cost(caster, rune_spell, SPELL_MANA) > op->stats.sp) { 125 if (SP_level_spellpoint_cost (caster, rune_spell, SPELL_MANA) > op->stats.sp)
126 {
125 new_draw_info(NDI_UNIQUE, 0,op,"You don't have enough mana."); 127 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough mana.");
126 return 0; 128 return 0;
127 } 129 }
130
128 if (SP_level_spellpoint_cost(caster, rune_spell, SPELL_GRACE) > op->stats.grace) { 131 if (SP_level_spellpoint_cost (caster, rune_spell, SPELL_GRACE) > op->stats.grace)
132 {
129 new_draw_info(NDI_UNIQUE, 0,op,"You don't have enough grace."); 133 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough grace.");
130 return 0; 134 return 0;
131 } 135 }
136
132 op->stats.grace -= SP_level_spellpoint_cost(caster, rune_spell, SPELL_GRACE); 137 op->stats.grace -= SP_level_spellpoint_cost (caster, rune_spell, SPELL_GRACE);
133 op->stats.sp -= SP_level_spellpoint_cost(caster, rune_spell, SPELL_MANA); 138 op->stats.sp -= SP_level_spellpoint_cost (caster, rune_spell, SPELL_MANA);
134 } 139 }
140
135 /* already proper rune. Note this should only be the case if other_arch was set */ 141 /* already proper rune. Note this should only be the case if other_arch was set */
136 if (rune_spell->type == RUNE) { 142 if (rune_spell->type == RUNE)
137 rune = rune_spell; 143 rune = rune_spell;
138 } else { 144 else
145 {
139 rune = get_archetype(GENERIC_RUNE); 146 rune = get_archetype (GENERIC_RUNE);
140 sprintf(buf,"You set off a rune of %s\n",rune_spell->name); 147 rune->msg = format ("You set off a rune of %s\n", &rune_spell->name);
141 rune->msg=add_string(buf); 148 rune->insert (rune_spell->clone ());
142 tmp = get_object(); 149
143 copy_object(rune_spell, tmp);
144 insert_ob_in_ob(tmp, rune);
145 if (spell->face != blank_face) 150 if (spell->face != blank_face)
146 rune->face = spell->face; 151 rune->face = spell->face;
147 } 152 }
153
148 rune->level = caster_level(caster, spell); 154 rune->level = casting_level (caster, spell);
149 rune->stats.Cha = rune->level/2; /* the invisibility parameter */ 155 rune->stats.Cha = rune->level / 2; /* the invisibility parameter */
150 rune->x=nx;
151 rune->y=ny;
152 rune->map = m;
153 rune->direction=dir; /* where any spell will go upon detonation */ 156 rune->direction = dir; /* where any spell will go upon detonation */
154 set_owner(rune,op); /* runes without need no owner */ 157 rune->set_owner (op); /* runes without need no owner */
155 set_spell_skill(op, caster, spell, rune); 158 set_spell_skill (op, caster, spell, rune);
156 insert_ob_in_map(rune,m,op,0); 159
160 m->insert (rune, nx, ny, op);
157 return 1; 161 return 1;
158
159} 162}
160
161
162 163
163/* move_rune: peterm 164/* move_rune: peterm
164 comments on runes: 165 comments on runes:
165 rune->level : level at which rune will cast its spell. 166 rune->level : level at which rune will cast its spell.
166 rune->hp : number of detonations before rune goes away 167 rune->hp : number of detonations before rune goes away
… …
170 rune->attacktype: type of damage it does, if not casting spells 171 rune->attacktype: type of damage it does, if not casting spells
171 rune->other_arch: spell in the rune 172 rune->other_arch: spell in the rune
172 rune->Cha : how hidden the rune is 173 rune->Cha : how hidden the rune is
173 rune->maxhp : number of spells the rune casts 174 rune->maxhp : number of spells the rune casts
174*/ 175*/
175 176void
176void move_rune(object *op) { 177move_rune (object *op)
177 int det=0; 178{
178 if(!op->level) {return;} /* runes of level zero cannot detonate. */ 179 /* runes of level zero cannot detonate. */
180 if (!op->level)
181 return;
182
179 det=op->invisible; 183 int det = op->invisible;
184
180 if(!(rndm(0, MAX(1,(op->stats.Cha))-1))) { 185 if (!(rndm (0, MAX (1, (op->stats.Cha)) - 1)))
186 {
181 op->invisible=0; 187 op->invisible = 0;
182 op->speed_left-=1; 188 op->speed_left -= 1;
183 } 189 }
184 else 190 else
185 op->invisible=1; 191 op->invisible = 1;
192
186 if(op->invisible!=det) 193 if (op->invisible != det)
187 update_object(op,UP_OBJ_FACE); 194 update_object (op, UP_OBJ_CHANGE);
188} 195}
189
190 196
191/* peterm: rune_attack 197/* peterm: rune_attack
192 * function handles those runes which detonate but do not cast spells. 198 * function handles those runes which detonate but do not cast spells.
193 */ 199 */
194 200void
195
196void rune_attack(object *op,object *victim) 201rune_attack (object *op, object *victim)
197{ 202{
198 if(victim) { 203 if (victim)
199 tag_t tag = victim->count; 204 {
200 hit_player(victim,op->stats.dam,op,op->attacktype,1); 205 hit_player (victim, op->stats.dam, op, op->attacktype, 1);
201 if (was_destroyed (victim, tag)) 206
207 if (victim->destroyed ())
202 return; 208 return;
209
203 /* if there's a disease in the needle, put it in the player */ 210 /* if there's a disease in the needle, put it in the player */
204 if(HAS_RANDOM_ITEMS(op)) create_treasure(op->randomitems,op,0, 211 if (op->has_random_items ())
205 (victim->map?victim->map->difficulty:1),0); 212 create_treasure (op->randomitems, op, 0, (victim->map ? victim->map->difficulty : 1), 0);
213
206 if(op->inv && op->inv->type == DISEASE) { 214 if (op->inv && op->inv->type == DISEASE)
215 {
207 object *disease=op->inv; 216 object *disease = op->inv;
217
208 infect_object(victim, disease, 1); 218 infect_object (victim, disease, 1);
209 remove_ob(disease); 219 disease->destroy ();
210 free_object(disease);
211 } 220 }
212 } 221 }
222 else
213 else hit_map(op,0,op->attacktype,1); 223 hit_map (op, 0, op->attacktype, 1);
214} 224}
215 225
216/* This function generalizes attacks by runes/traps. This ought to make 226/* This function generalizes attacks by runes/traps. This ought to make
217 * it possible for runes to attack from the inventory, 227 * it possible for runes to attack from the inventory,
218 * it'll spring the trap on the victim. 228 * it'll spring the trap on the victim.
219 */ 229 */
230void
220void spring_trap(object *trap,object *victim) 231spring_trap (object *trap, object *victim)
221{ 232{
222 object *env; 233 object *env;
223 tag_t trap_tag = trap->count;
224 rv_vector rv; 234 rv_vector rv;
225 int i; 235 int i;
226 236
227 /* Prevent recursion */ 237 /* Prevent recursion */
228 if (trap->stats.hp <= 0) 238 if (trap->stats.hp <= 0)
239 return;
240
241 if (QUERY_FLAG (trap, FLAG_IS_LINKED))
242 use_trigger (trap);
243
244 /* Only living objects can trigger runes that don't cast spells, as
245 * doing direct damage to a non-living object doesn't work anyway.
246 * Typical example is an arrow attacking a door.
247 */
248 if (!QUERY_FLAG (victim, FLAG_ALIVE) && !trap->inv && !trap->other_arch)
249 return;
250
251 trap->stats.hp--; /*decrement detcount */
252
253 if (victim && victim->type == PLAYER)
254 new_draw_info (NDI_UNIQUE, 0, victim, trap->msg);
255
256 /* Flash an image of the trap on the map so the poor sod
257 * knows what hit him.
258 */
259 env = trap->outer_env ();
260
261 /* If the victim is not next to this trap, don't set it off.
262 * players shouldn't get hit by firing arrows at a door for example.
263 * At the same time, the trap will stick around until detonated
264 */
265 get_rangevector (env, victim, &rv, 0);
266 if (rv.distance > 1)
267 return;
268
269 env->play_sound (trap->sound ? trap->sound : sound_find ("trap_spring"));
270
271 trap_show (trap, env);
272
273 if (victim->type == PLAYER) // only count players as enemies
274 trap->enemy = victim; // set the victim as the traps enemy, so that summoned
275 // creatures know who to attack.
276
277 /* Only if it is a spell do we proceed here */
278 if ((trap->inv && trap->inv->type == SPELL) || (trap->other_arch && trap->other_arch->type == SPELL))
279 {
280 if (trap->destroyed ())
229 return; 281 return;
230 282
231 if (QUERY_FLAG(trap,FLAG_IS_LINKED)) 283 // breaks summon golem spells, which, for inexplicable reasons,
232 use_trigger(trap); 284 // do not work like summon golem spells at all but still require
285 // direction "0" to work at all.
286 //if (trap->direction)
287 // rv.direction = trap->direction;
233 288
234 /* Only living objects can trigger runes that don't cast spells, as 289 for (i = 0; i < MAX (1, trap->stats.maxhp); i++)
235 * doing direct damage to a non-living object doesn't work anyway. 290 {
236 * Typical example is an arrow attacking a door. 291 if (trap->inv)
237 */ 292 cast_spell (env, trap, trap->direction, trap->inv, NULL);
238 if ( ! QUERY_FLAG (victim, FLAG_ALIVE) && !trap->inv && !trap->other_arch) 293 else
294 {
295 object *spell = arch_to_object (trap->other_arch);
296
297 cast_spell (env, trap, trap->direction, spell, NULL);
298 spell->destroy ();
299 }
300 }
301 }
302 else
303 {
304 rune_attack (trap, victim);
305 if (trap->destroyed ())
239 return; 306 return;
240
241 trap->stats.hp--; /*decrement detcount */
242
243 if(victim && victim->type==PLAYER)
244 new_draw_info(NDI_UNIQUE, 0,victim,trap->msg);
245
246 /* Flash an image of the trap on the map so the poor sod
247 * knows what hit him.
248 */
249 env = object_get_env_recursive(trap);
250
251 /* If the victim is not next to this trap, don't set it off.
252 * players shouldn't get hit by firing arrows at a door for example.
253 * At the same time, the trap will stick around until detonated
254 */
255 get_rangevector(env, victim, &rv, 0);
256 if (rv.distance > 1) return;
257
258 trap_show(trap,env);
259
260 /* Only if it is a spell do we proceed here */
261 if ((trap->inv && trap->inv->type == SPELL) ||
262 (trap->other_arch && trap->other_arch->clone.type == SPELL)) {
263
264 if (was_destroyed (trap, trap_tag))
265 return;
266
267 // breaks summon golem spells, which, for inexplicable reasons,
268 // do not work like summon golem spells at all but still require
269 // direction "0" to work at all.
270 //if (trap->direction)
271 // rv.direction = trap->direction;
272
273 for(i = 0; i < MAX(1, trap->stats.maxhp); i++) {
274 if (trap->inv)
275 cast_spell(env,trap,trap->direction,trap->inv,NULL);
276 else {
277 object *spell = arch_to_object(trap->other_arch);
278 cast_spell(env,trap,trap->direction,spell,NULL);
279 free_object(spell);
280 }
281 }
282 } else {
283 rune_attack(trap,victim);
284 if (was_destroyed (trap, trap_tag))
285 return;
286 } 307 }
287 308
288 if (trap->stats.hp <= 0) { 309 if (trap->stats.hp <= 0)
310 {
289 trap->type=SIGN; /* make the trap impotent */ 311 trap->type = SIGN; /* make the trap impotent */
290 trap->stats.food=20; /* make it stick around until its spells are gone */ 312 trap->stats.food = 20; /* make it stick around until its spells are gone */
291 SET_FLAG(trap,FLAG_IS_USED_UP); 313 SET_FLAG (trap, FLAG_IS_USED_UP);
292 } 314 }
293} 315}
294 316
295/* dispel_rune: by peterm 317/* dispel_rune: by peterm
296 * dispels the target rune, depending on the level of the actor 318 * dispels the target rune, depending on the level of the actor
297 * and the level of the rune risk flag, if true, means that there is 319 * and the level of the rune risk flag, if true, means that there is
298 * a chance that the trap/rune will detonate 320 * a chance that the trap/rune will detonate
299 */ 321 */
322int
300int dispel_rune(object *op,object *caster, object *spell, object *skill, int dir) 323dispel_rune (object *op, object *caster, object *spell, object *skill, int dir)
301{ 324{
302 object *tmp,*tmp2; 325 object *tmp, *tmp2;
303 int searchflag = 1, mflags; 326 int searchflag = 1, mflags;
304 sint16 x,y; 327 sint16 x, y;
305 mapstruct *m; 328 maptile *m;
306 329
307 x = op->x+freearr_x[dir]; 330 x = op->x + freearr_x[dir];
308 y = op->y+freearr_y[dir]; 331 y = op->y + freearr_y[dir];
309 m = op->map; 332 m = op->map;
310 333
311 mflags = get_map_flags(m, &m, x, y, &x, &y); 334 mflags = get_map_flags (m, &m, x, y, &x, &y);
312 335
313 /* Should we perhaps not allow player to disable traps if a monster/ 336 /* Should we perhaps not allow player to disable traps if a monster/
314 * player is standing on top? 337 * player is standing on top?
315 */ 338 */
316 if (mflags & P_OUT_OF_MAP) { 339 if (mflags & P_OUT_OF_MAP)
340 {
317 new_draw_info(NDI_UNIQUE, 0,op,"There's nothing there!"); 341 new_draw_info (NDI_UNIQUE, 0, op, "There's nothing there!");
318 return 0; 342 return 0;
343 }
344
345 for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
319 } 346 {
320
321 for(tmp=get_map_ob(m,x, y); tmp!=NULL; tmp=tmp->above) {
322 if(tmp->type==RUNE || tmp->type==TRAP) break; 347 if (tmp->type == RUNE || tmp->type == TRAP)
348 break;
323 349
324 /* we could put a probability chance here, but since nothing happens 350 /* we could put a probability chance here, but since nothing happens
325 * if you fail, no point on that. I suppose we could do a level 351 * if you fail, no point on that. I suppose we could do a level
326 * comparison so low level players can't erase high level players runes. 352 * comparison so low level players can't erase high level players runes.
327 */ 353 */
328 if (tmp->type == SIGN && !strcmp(tmp->arch->name,"rune_mark")) { 354 if (tmp->type == SIGN && tmp->arch->archname == shstr_rune_mark)
329 remove_ob(tmp); 355 {
330 free_object(tmp); 356 tmp->destroy ();
331 new_draw_info(NDI_UNIQUE, 0,op,"You wipe out the rune of marking!"); 357 new_draw_info (NDI_UNIQUE, 0, op, "You wipe out the rune of marking!");
332 return 1; 358 return 1;
333 } 359 }
334 360
335 /* now search tmp's inventory for traps 361 /* now search tmp's inventory for traps
336 * This is for chests, where the rune is in the chests inventory. 362 * This is for chests, where the rune is in the chests inventory.
337 */ 363 */
338 for(tmp2=tmp->inv;tmp2!=NULL;tmp2=tmp2->below) { 364 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
365 {
339 if(tmp2->type==RUNE || tmp2->type==TRAP) { 366 if (tmp2->type == RUNE || tmp2->type == TRAP)
367 {
340 tmp=tmp2; 368 tmp = tmp2;
341 searchflag=0; 369 searchflag = 0;
342 break; 370 break;
343 } 371 }
344 } 372 }
373
345 if(!searchflag) break; 374 if (!searchflag)
375 break;
346 } 376 }
347 377
348 /* no rune there. */ 378 /* no rune there. */
349 if(tmp==NULL) { 379 if (tmp == NULL)
380 {
350 new_draw_info(NDI_UNIQUE, 0,op,"There's nothing there!"); 381 new_draw_info (NDI_UNIQUE, 0, op, "There's nothing there!");
351 return 0; 382 return 0;
352 } 383 }
384
353 trap_disarm(op,tmp,0, skill); 385 trap_disarm (op, tmp, 0, skill);
354 return 1; 386 return 1;
355
356} 387}
357 388
389int
358int trap_see(object *op,object *trap) { 390trap_see (object *op, object *trap)
391{
359 int chance; 392 int chance;
360 393
361 chance = random_roll(0, 99, op, PREFER_HIGH);; 394 chance = random_roll (0, 99, op, PREFER_HIGH);;
362 395
363 /* decide if we see the rune or not */ 396 /* decide if we see the rune or not */
364 if((trap->stats.Cha==1) || (chance > MIN(95,MAX(5,((int)((float) (op->map->difficulty 397 if ((trap->stats.Cha == 1) || (chance > MIN (95, MAX (5, ((int) ((float) (op->map->difficulty
365 + trap->level + trap->stats.Cha-op->level)/10.0 * 50.0)))))) { 398 + trap->level + trap->stats.Cha - op->level) / 10.0 * 50.0))))))
399 {
366 new_draw_info_format(NDI_UNIQUE, 0,op,"You spot a %s!",trap->name); 400 new_draw_info_format (NDI_UNIQUE, 0, op, "You spot a %s!", &trap->name);
367 return 1; 401 return 1;
368 } 402 }
403
404 return 0;
405}
406
407int
408trap_show (object *trap, object *where)
409{
410 if (where == NULL)
369 return 0; 411 return 0;
370}
371 412
372int trap_show(object *trap, object *where) {
373 object *tmp2;
374
375 if(where==NULL) return 0;
376 tmp2=get_archetype("runedet"); 413 object *tmp = get_archetype ("runedet");
377 tmp2->face=&new_faces[GET_ANIMATION(trap, 0)]; 414 tmp->face = GET_ANIMATION (trap, 0);
378 tmp2->x=where->x;tmp2->y=where->y;tmp2->map=where->map; 415 tmp->insert_at (where, 0);
379 insert_ob_in_map(tmp2,where->map,NULL,0); 416
380 return 1; 417 return 1;
381
382} 418}
383 419
384 420int
385int trap_disarm(object *disarmer, object *trap, int risk, object *skill) { 421trap_disarm (object *disarmer, object *trap, int risk, object *skill)
422{
386 int trapworth; /* need to compute the experience worth of the trap 423 int trapworth; /* need to compute the experience worth of the trap before we kill it */
387 before we kill it */
388 424
389 /* this formula awards a more reasonable amount of exp */ 425 /* this formula awards a more reasonable amount of exp */
390 trapworth = MAX(1,trap->level) * disarmer->map->difficulty * 426 trapworth = MAX (1, trap->level)
427 * disarmer->map->difficulty
391 sqr(MAX(trap->stats.dam,trap->inv?trap->inv->level:1)) / 428 * sqr (MAX (trap->stats.dam, trap->inv ? trap->inv->level : 1))
392 skill->level; 429 / skill->level;
393 430
394 if(!(random_roll(0, (MAX(2, MIN(20,trap->level-skill->level 431 if (!(random_roll (0, (MAX (2, MIN (20, trap->level - skill->level + 5 - disarmer->stats.Dex / 2)) - 1), disarmer, PREFER_LOW)))
395 +5 - disarmer->stats.Dex/2))-1), disarmer, PREFER_LOW))) 432 {
396 { 433 new_draw_info_format (NDI_UNIQUE, 0, disarmer, "You successfully disarm the %s!", &trap->name);
397 new_draw_info_format(NDI_UNIQUE, 0,disarmer, 434 trap->destroy ();
398 "You successfully disarm the %s!",trap->name); 435
399 destroy_object(trap);
400 /* If it is your own trap, (or any players trap), don't you don't 436 /* If it is your own trap, (or any players trap), don't you don't
401 * get exp for it. 437 * get exp for it.
402 */ 438 */
403 if (trap->owner && trap->owner->type!=PLAYER && risk) 439 if (trap->owner && trap->owner->type != PLAYER && risk)
404 return trapworth; 440 return trapworth;
405 else return 1; /* give minimal exp and say success */
406 }
407 else 441 else
442 return 1; /* give minimal exp and say success */
443 }
444 else
445 {
446 new_draw_info_format (NDI_UNIQUE, 0, disarmer, "You fail to disarm the %s.", &trap->name);
447 if (!(random_roll (0, (MAX (2, skill->level - trap->level + disarmer->stats.Dex / 2 - 6)) - 1, disarmer, PREFER_LOW)) && risk)
408 { 448 {
409 new_draw_info_format(NDI_UNIQUE, 0,disarmer,
410 "You fail to disarm the %s.",trap->name);
411 if(! (random_roll(0, (MAX(2,skill->level-trap->level
412 + disarmer->stats.Dex/2-6))-1, disarmer, PREFER_LOW)) &&risk) {
413 new_draw_info(NDI_UNIQUE, 0,disarmer,"In fact, you set it off!"); 449 new_draw_info (NDI_UNIQUE, 0, disarmer, "In fact, you set it off!");
414 spring_trap(trap,disarmer); 450 spring_trap (trap, disarmer);
415 } 451 }
416 return 0; 452 return 0;
417 } 453 }
418} 454}
419
420 455
421/* traps need to be adjusted for the difficulty of the map. The 456/* traps need to be adjusted for the difficulty of the map. The
422 * default traps are too strong for wimpy level 1 players, and 457 * default traps are too strong for wimpy level 1 players, and
423 * unthreatening to anyone of high level 458 * unthreatening to anyone of high level
424 */ 459 */
425 460void
426void trap_adjust(object *trap, int difficulty) { 461trap_adjust (object *trap, int difficulty)
462{
427 int i; 463 int i;
428 464
429 /* now we set the trap level to match the difficulty of the level 465 /* now we set the trap level to match the difficulty of the level
430 * the formula below will give a level from 1 to (2*difficulty) with 466 * the formula below will give a level from 1 to (2*difficulty) with
431 * a peak probability at difficulty 467 * a peak probability at difficulty
432 */ 468 */
433 469
434 trap->level = rndm(0, difficulty-1) + rndm(0, difficulty-1); 470 trap->level = rndm (0, difficulty - 1) + rndm (0, difficulty - 1);
435 if(trap->level < 1) 471 if (trap->level < 1)
436 trap->level = 1; 472 trap->level = 1;
437 473
438 /* set the hiddenness of the trap, similar formula to above */ 474 /* set the hiddenness of the trap, similar formula to above */
439 trap->stats.Cha = rndm(0, 19) + rndm(0, difficulty-1) + rndm(0, difficulty-1); 475 trap->stats.Cha = rndm (0, 19) + rndm (0, difficulty - 1) + rndm (0, difficulty - 1);
440 476
441 if (!trap->other_arch && !trap->inv) { 477 if (!trap->other_arch && !trap->inv)
478 {
442 /* set the damage of the trap. 479 /* set the damage of the trap.
443 * we get 0-4 pts of damage per level of difficulty of the map in 480 * we get 0-4 pts of damage per level of difficulty of the map in
444 * the trap 481 * the trap
445 */ 482 */
446 483
447 trap->stats.dam = 0; 484 trap->stats.dam = 0;
448 for(i=0;i<difficulty;i++) 485 for (i = 0; i < difficulty; i++)
449 trap->stats.dam+=rndm(0, 4); 486 trap->stats.dam += rndm (0, 4);
450 487
451 /* the poison trap special case */ 488 /* the poison trap special case */
452 if(trap->attacktype & AT_POISON) { 489 if (trap->attacktype & AT_POISON)
490 {
453 trap->stats.dam = rndm(0, difficulty-1); 491 trap->stats.dam = rndm (0, difficulty - 1);
454 if(trap->stats.dam < 1) 492 if (trap->stats.dam < 1)
455 trap->stats.dam = 1; 493 trap->stats.dam = 1;
456 } 494 }
457 495
458 /* so we get an appropriate amnt of exp for AT_DEATH traps */ 496 /* so we get an appropriate amnt of exp for AT_DEATH traps */
459 if(trap->attacktype & AT_DEATH) trap->stats.dam = 127; 497 if (trap->attacktype & AT_DEATH)
498 trap->stats.dam = 127;
460 } 499 }
461 500
462} 501}
463

Diff Legend

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