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

Comparing deliantra/server/common/button.C (file contents):
Revision 1.5 by root, Thu Aug 31 17:54:14 2006 UTC vs.
Revision 1.18 by root, Thu Dec 21 01:33:49 2006 UTC

1/*
2 * static char *rcsid_button_c =
3 * "$Id: button.C,v 1.5 2006/08/31 17:54:14 root Exp $";
4 */
5
6/* 1/*
7 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
8 3
9 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
21 16
22 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 20
26 The authors can be reached via e-mail at crossfire-devel@real-time.com 21 The authors can be reached via e-mail at <crossfire@schmorp.de>
27*/ 22*/
28 23
29#include <global.h> 24#include <global.h>
30#include <funcpoint.h> 25#include <funcpoint.h>
31 26
… …
37 * elmex: 32 * elmex:
38 * This function takes a objectlink list with all the objects are going to be activated. 33 * This function takes a objectlink list with all the objects are going to be activated.
39 * state is a true/false flag that will actiavte objects that have FLAG_ACTIVATE_ON_PUSH/RELEASE set. 34 * state is a true/false flag that will actiavte objects that have FLAG_ACTIVATE_ON_PUSH/RELEASE set.
40 * The source argument can be 0 or the source object for this activation. 35 * The source argument can be 0 or the source object for this activation.
41 */ 36 */
37void
42void activate_connection_link (objectlink *ol, bool state, object *source = 0) 38activate_connection_link (objectlink * ol, bool state, object *source = 0)
43{ 39{
44 object *tmp = 0; 40 object *tmp = 0;
45 41
46 for (; ol; ol = ol->next) 42 for (; ol; ol = ol->next)
47 { 43 {
48 if (!ol->ob || ol->ob->count != ol->id) 44 if (!ol->ob)
49 { 45 {
50 LOG (llevError, "Internal error in activate_connection_link (%ld).\n", ol->id); 46 LOG (llevError, "Internal error in activate_connection_link.\n");
51 continue; 47 continue;
52 } 48 }
49
53 /* a button link object can become freed when the map is saving. As 50 /* a button link object can become freed when the map is saving. As
54 * a map is saved, objects are removed and freed, and if an object is 51 * a map is saved, objects are removed and freed, and if an object is
55 * on top of a button, this function is eventually called. If a map 52 * on top of a button, this function is eventually called. If a map
56 * is getting moved out of memory, the status of buttons and levers 53 * is getting moved out of memory, the status of buttons and levers
57 * probably isn't important - it will get sorted out when the map is 54 * probably isn't important - it will get sorted out when the map is
… …
68 if (!state && !QUERY_FLAG (tmp, FLAG_ACTIVATE_ON_RELEASE)) 65 if (!state && !QUERY_FLAG (tmp, FLAG_ACTIVATE_ON_RELEASE))
69 continue; 66 continue;
70 67
71 switch (tmp->type) 68 switch (tmp->type)
72 { 69 {
73 case GATE: 70 case GATE:
74 case HOLE: 71 case HOLE:
75 tmp->value = tmp->stats.maxsp ? !state : state; 72 tmp->value = tmp->stats.maxsp ? !state : state;
76 tmp->speed = 0.5; 73 tmp->speed = 0.5;
77 update_ob_speed (tmp);
78 break;
79
80 case CF_HANDLE:
81 SET_ANIMATION (tmp,
82 (tmp->value =
83 tmp->stats.maxsp ? !state : state));
84 update_object (tmp, UP_OBJ_FACE);
85 break;
86
87 case SIGN:
88 if (!tmp->stats.food || tmp->last_eat < tmp->stats.food)
89 {
90 new_info_map (NDI_UNIQUE | NDI_NAVY, tmp->map, tmp->msg);
91 if (tmp->stats.food)
92 tmp->last_eat++;
93 }
94 break;
95
96 case ALTAR:
97 tmp->value = 1;
98 SET_ANIMATION (tmp, tmp->value);
99 update_object (tmp, UP_OBJ_FACE);
100 break;
101
102 case BUTTON:
103 case PEDESTAL:
104 tmp->value = state;
105 SET_ANIMATION (tmp, tmp->value);
106 update_object (tmp, UP_OBJ_FACE);
107 break;
108
109 case MOOD_FLOOR:
110 do_mood_floor (tmp, source);
111 break;
112
113 case TIMED_GATE:
114 tmp->speed = tmp->arch->clone.speed;
115 update_ob_speed (tmp); /* original values */
116 tmp->value = tmp->arch->clone.value;
117 tmp->stats.sp = 1;
118 tmp->stats.hp = tmp->stats.maxhp;
119 /* Handle multipart gates. We copy the value for the other parts
120 * from the head - this ensures that the data will consistent
121 */
122 for (tmp = tmp->more; tmp != NULL; tmp = tmp->more)
123 {
124 tmp->speed = tmp->head->speed;
125 tmp->value = tmp->head->value;
126 tmp->stats.sp = tmp->head->stats.sp;
127 tmp->stats.hp = tmp->head->stats.hp;
128 update_ob_speed (tmp); 74 update_ob_speed (tmp);
129 }
130 break; 75 break;
131 76
77 case CF_HANDLE:
78 SET_ANIMATION (tmp, (tmp->value = tmp->stats.maxsp ? !state : state));
79 update_object (tmp, UP_OBJ_FACE);
80 break;
81
82 case SIGN:
83 if (!tmp->stats.food || tmp->last_eat < tmp->stats.food)
84 {
85 new_info_map (NDI_UNIQUE | NDI_NAVY, tmp->map, tmp->msg);
86 if (tmp->stats.food)
87 tmp->last_eat++;
88 }
89 break;
90
91 case ALTAR:
92 tmp->value = 1;
93 SET_ANIMATION (tmp, tmp->value);
94 update_object (tmp, UP_OBJ_FACE);
95 break;
96
97 case BUTTON:
98 case PEDESTAL:
99 tmp->value = state;
100 SET_ANIMATION (tmp, tmp->value);
101 update_object (tmp, UP_OBJ_FACE);
102 break;
103
104 case MOOD_FLOOR:
105 do_mood_floor (tmp, source);
106 break;
107
108 case TIMED_GATE:
109 tmp->speed = tmp->arch->clone.speed;
110 update_ob_speed (tmp); /* original values */
111 tmp->value = tmp->arch->clone.value;
112 tmp->stats.sp = 1;
113 tmp->stats.hp = tmp->stats.maxhp;
114 /* Handle multipart gates. We copy the value for the other parts
115 * from the head - this ensures that the data will consistent
116 */
117 for (tmp = tmp->more; tmp != NULL; tmp = tmp->more)
118 {
119 tmp->speed = tmp->head->speed;
120 tmp->value = tmp->head->value;
121 tmp->stats.sp = tmp->head->stats.sp;
122 tmp->stats.hp = tmp->head->stats.hp;
123 update_ob_speed (tmp);
124 }
125 break;
126
132 case DIRECTOR: 127 case DIRECTOR:
133 case FIREWALL: 128 case FIREWALL:
134 if (!QUERY_FLAG (tmp, FLAG_ANIMATE) && tmp->type == FIREWALL) 129 if (!QUERY_FLAG (tmp, FLAG_ANIMATE) && tmp->type == FIREWALL)
135 move_firewall (tmp); 130 move_firewall (tmp);
136 else 131 else
137 { 132 {
138 if ((tmp->stats.sp += tmp->stats.maxsp) > 8) /* next direction */ 133 if ((tmp->stats.sp += tmp->stats.maxsp) > 8) /* next direction */
139 tmp->stats.sp = ((tmp->stats.sp - 1) % 8) + 1; 134 tmp->stats.sp = ((tmp->stats.sp - 1) % 8) + 1;
140 animate_turning (tmp); 135 animate_turning (tmp);
141 } 136 }
142 break; 137 break;
143 138
144 case TELEPORTER: 139 case TELEPORTER:
145 move_teleporter (tmp); 140 move_teleporter (tmp);
146 break; 141 break;
147 142
148 case CREATOR: 143 case CREATOR:
149 move_creator (tmp); 144 move_creator (tmp);
150 break; 145 break;
151 146
152 case TRIGGER_MARKER: 147 case TRIGGER_MARKER:
153 move_marker (tmp); 148 move_marker (tmp);
154 break; 149 break;
155 150
156 case DUPLICATOR: 151 case DUPLICATOR:
157 move_duplicator (tmp); 152 move_duplicator (tmp);
158 break; 153 break;
159 } 154 }
160 } 155 }
161} 156}
162 157
163/* 158/*
… …
170 * altars/pedestals/holes in the whole map. 165 * altars/pedestals/holes in the whole map.
171 * Changed the routine to loop through _all_ objects. 166 * Changed the routine to loop through _all_ objects.
172 * Better hurry with that linked list... 167 * Better hurry with that linked list...
173 * 168 *
174 */ 169 */
170void
175void push_button (object *op) 171push_button (object *op)
176{ 172{
177 oblinkpt *obp = get_button_links (op); 173 oblinkpt *obp = get_button_links (op);
178 174
179 if (!obp) 175 if (!obp)
180 return; 176 return;
181 177
182 if (INVOKE_MAP (TRIGGER, op->map, ARG_INT64(obp->value), ARG_INT(op->value))) 178 if (INVOKE_MAP (TRIGGER, op->map, ARG_INT64 (obp->value), ARG_INT (op->value)))
183 return; 179 return;
184 180
185 activate_connection_link (obp->link, op->value, op); 181 activate_connection_link (obp->link, op->value, op);
186} 182}
187 183
… …
191 * only a map, a connection value and a true or false flag that indicated whether 187 * only a map, a connection value and a true or false flag that indicated whether
192 * the connection was 'state' or 'released'. So that you can activate objects 188 * the connection was 'state' or 'released'. So that you can activate objects
193 * who have FLAG_ACTIVATE_ON_PUSH/RELEASE set properly. 189 * who have FLAG_ACTIVATE_ON_PUSH/RELEASE set properly.
194 * 190 *
195 */ 191 */
192void
196void activate_connection (mapstruct *map, long connection, bool state) 193activate_connection (maptile *map, long connection, bool state)
197{ 194{
198 if (INVOKE_MAP (TRIGGER, map, ARG_INT64(connection), ARG_INT(state))) 195 if (INVOKE_MAP (TRIGGER, map, ARG_INT64 (connection), ARG_INT (state)))
199 return; 196 return;
200 197
201 oblinkpt *obp = get_connection_links (map, connection); 198 oblinkpt *obp = get_connection_links (map, connection);
199
202 if (obp) 200 if (obp)
203 activate_connection_link (obp->link, state); 201 activate_connection_link (obp->link, state);
204} 202}
205 203
206/* 204/*
207 * Updates everything connected with the button op. 205 * Updates everything connected with the button op.
208 * After changing the state of a button, this function must be called 206 * After changing the state of a button, this function must be called
209 * to make sure that all gates and other buttons connected to the 207 * to make sure that all gates and other buttons connected to the
210 * button reacts to the (eventual) change of state. 208 * button reacts to the (eventual) change of state.
211 */ 209 */
212 210void
213void update_button(object *op) { 211update_button (object *op)
212{
214 object *ab,*tmp,*head; 213 object *ab, *tmp, *head;
215 int tot,any_down=0, old_value=op->value; 214 int tot, any_down = 0, old_value = op->value;
216 oblinkpt *obp = 0; 215 oblinkpt *obp = 0;
217 objectlink *ol; 216 objectlink *ol;
218 217
219 obp = get_button_links (op); 218 obp = get_button_links (op);
220 /* LOG(llevDebug, "update_button: %s (%d)\n", op->name, op->count); */ 219 /* LOG(llevDebug, "update_button: %s (%d)\n", op->name, op->count); */
221 if (obp) 220 if (obp)
222 for (ol = obp->link; ol; ol = ol->next) { 221 for (ol = obp->link; ol; ol = ol->next)
223 if (!ol->ob || ol->ob->count != ol->id) { 222 {
223 if (!ol->ob)
224 {
224 LOG(llevDebug, "Internal error in update_button (%s).\n", op->name); 225 LOG (llevDebug, "Internal error in update_button (%s).\n", &op->name);
225 continue; 226 continue;
226 } 227 }
228
227 tmp = ol->ob; 229 tmp = ol->ob;
228 if (tmp->type==BUTTON) { 230 if (tmp->type == BUTTON)
231 {
229 for(ab=tmp->above,tot=0;ab!=NULL;ab=ab->above) 232 for (ab = tmp->above, tot = 0; ab != NULL; ab = ab->above)
230 /* Bug? The pedestal code below looks for the head of 233 /* Bug? The pedestal code below looks for the head of
231 * the object, this bit doesn't. I'd think we should check 234 * the object, this bit doesn't. I'd think we should check
232 * for head here also. Maybe it also makese sense to 235 * for head here also. Maybe it also makese sense to
233 * make the for ab=tmp->above loop common, and alter 236 * make the for ab=tmp->above loop common, and alter
234 * behaviour based on object within that loop? 237 * behaviour based on object within that loop?
235 */ 238 */
236 239
237 /* Basically, if the move_type matches that on what the 240 /* Basically, if the move_type matches that on what the
238 * button wants, we count it. The second check is so that 241 * button wants, we count it. The second check is so that
239 * objects don't move (swords, etc) will count. Note that 242 * objects don't move (swords, etc) will count. Note that
240 * this means that more work is needed to make buttons 243 * this means that more work is needed to make buttons
241 * that are only triggered by flying objects. 244 * that are only triggered by flying objects.
242 */ 245 */
243 if ((ab->move_type & tmp->move_on) || ab->move_type==0 ) 246 if ((ab->move_type & tmp->move_on) || ab->move_type == 0)
244 tot+=ab->weight*(ab->nrof?ab->nrof:1)+ab->carrying; 247 tot += ab->weight * (ab->nrof ? ab->nrof : 1) + ab->carrying;
245 248
246 tmp->value=(tot>=tmp->weight)?1:0; 249 tmp->value = (tot >= tmp->weight) ? 1 : 0;
247 if(tmp->value) 250 if (tmp->value)
248 any_down=1; 251 any_down = 1;
252 }
249 } else if (tmp->type == PEDESTAL) { 253 else if (tmp->type == PEDESTAL)
254 {
250 tmp->value = 0; 255 tmp->value = 0;
251 for(ab=tmp->above; ab!=NULL; ab=ab->above) { 256 for (ab = tmp->above; ab != NULL; ab = ab->above)
257 {
252 head = ab->head ? ab->head : ab; 258 head = ab->head ? ab->head : ab;
253 /* Same note regarding move_type for buttons above apply here. */ 259 /* Same note regarding move_type for buttons above apply here. */
254 if ( ((head->move_type & tmp->move_on) || ab->move_type==0) && 260 if (((head->move_type & tmp->move_on) || ab->move_type == 0) &&
255 (head->race==tmp->slaying || 261 (head->race == tmp->slaying ||
256 ((head->type==SPECIAL_KEY) && (head->slaying==tmp->slaying)) || 262 ((head->type == SPECIAL_KEY) && (head->slaying == tmp->slaying)) ||
257 (!strcmp (tmp->slaying, "player") && 263 (!strcmp (tmp->slaying, "player") && head->type == PLAYER)))
258 head->type == PLAYER)))
259 tmp->value = 1; 264 tmp->value = 1;
260 } 265 }
261 if(tmp->value) 266 if (tmp->value)
262 any_down=1; 267 any_down = 1;
263 } 268 }
264 } 269 }
265 if(any_down) /* If any other buttons were down, force this to remain down */ 270 if (any_down) /* If any other buttons were down, force this to remain down */
266 op->value=1; 271 op->value = 1;
267 272
268 /* If this button hasn't changed, don't do anything */ 273 /* If this button hasn't changed, don't do anything */
269 if (op->value != old_value) { 274 if (op->value != old_value)
275 {
270 SET_ANIMATION(op, op->value); 276 SET_ANIMATION (op, op->value);
271 update_object(op, UP_OBJ_FACE); 277 update_object (op, UP_OBJ_FACE);
272 push_button(op); /* Make all other buttons the same */ 278 push_button (op); /* Make all other buttons the same */
273 } 279 }
274} 280}
275 281
276/* 282/*
277 * Updates every button on the map (by calling update_button() for them). 283 * Updates every button on the map (by calling update_button() for them).
278 */ 284 */
279 285
280void update_buttons(mapstruct *m) { 286void
287update_buttons (maptile *m)
288{
281 objectlink *ol; 289 objectlink *ol;
282 oblinkpt *obp; 290 oblinkpt *obp;
291
283 for (obp = m->buttons; obp; obp = obp->next) 292 for (obp = m->buttons; obp; obp = obp->next)
284 for (ol = obp->link; ol; ol = ol->next) { 293 for (ol = obp->link; ol; ol = ol->next)
285 if (!ol->ob || ol->ob->count != ol->id) { 294 {
295 if (!ol->ob)
296 {
286 LOG(llevError, "Internal error in update_button (%s (%dx%d):%d, connected %ld).\n", 297 LOG (llevError, "Internal error in update_button (%s (%dx%d), connected %ld).\n",
287 ol->ob?(const char *)ol->ob->name:"null", 298 ol->ob ? (const char *) ol->ob->name : "null", ol->ob ? ol->ob->x : -1, ol->ob ? ol->ob->y : -1, obp->value);
288 ol->ob?ol->ob->x:-1,
289 ol->ob?ol->ob->y:-1,
290 ol->id,
291 obp->value);
292 continue; 299 continue;
300 }
301
302 if (ol->ob->type == BUTTON || ol->ob->type == PEDESTAL)
303 {
304 update_button (ol->ob);
305 break;
306 }
293 } 307 }
294 if (ol->ob->type==BUTTON || ol->ob->type==PEDESTAL)
295 {
296 update_button(ol->ob);
297 break;
298 }
299 }
300} 308}
301 309
310void
302void use_trigger(object *op) 311use_trigger (object *op)
303{ 312{
304 313
305 /* Toggle value */ 314 /* Toggle value */
306 op->value = !op->value; 315 op->value = !op->value;
307 push_button(op); 316 push_button (op);
308} 317}
309 318
310/* 319/*
311 * Note: animate_object should be used instead of this, 320 * Note: animate_object should be used instead of this,
312 * but it can't handle animations in the 8 directions 321 * but it can't handle animations in the 8 directions
313 */ 322 */
314 323
324void
315void animate_turning(object *op) /* only one part objects */ 325animate_turning (object *op) /* only one part objects */
316{ 326{
317 if (++op->state >= NUM_ANIMATIONS(op)/8) 327 if (++op->state >= NUM_ANIMATIONS (op) / 8)
318 op->state=0; 328 op->state = 0;
319 SET_ANIMATION(op, (op->stats.sp-1) * NUM_ANIMATIONS(op) / 8 + 329 SET_ANIMATION (op, (op->stats.sp - 1) * NUM_ANIMATIONS (op) / 8 + op->state);
320 op->state);
321 update_object(op,UP_OBJ_FACE); 330 update_object (op, UP_OBJ_FACE);
322} 331}
323 332
324#define ARCH_SACRIFICE(xyz) ((xyz)->slaying) 333#define ARCH_SACRIFICE(xyz) ((xyz)->slaying)
325#define NROF_SACRIFICE(xyz) ((uint32)(xyz)->stats.food) 334#define NROF_SACRIFICE(xyz) ((uint32)(xyz)->stats.food)
326 335
… …
332 * 341 *
333 * 0.93.4: Linked objects (ie, objects that are connected) can not be 342 * 0.93.4: Linked objects (ie, objects that are connected) can not be
334 * sacrificed. This fixes a bug of trying to put multiple altars/related 343 * sacrificed. This fixes a bug of trying to put multiple altars/related
335 * objects on the same space that take the same sacrifice. 344 * objects on the same space that take the same sacrifice.
336 */ 345 */
337 346
347int
338int check_altar_sacrifice (const object *altar, const object *sacrifice) 348check_altar_sacrifice (const object *altar, const object *sacrifice)
339{ 349{
340 if ( ! QUERY_FLAG (sacrifice, FLAG_ALIVE) 350 if (!QUERY_FLAG (sacrifice, FLAG_ALIVE) && !QUERY_FLAG (sacrifice, FLAG_IS_LINKED) && sacrifice->type != PLAYER)
341 && ! QUERY_FLAG (sacrifice, FLAG_IS_LINKED)
342 && sacrifice->type != PLAYER)
343 { 351 {
344 if ((ARCH_SACRIFICE(altar) == sacrifice->arch->name || 352 if ((ARCH_SACRIFICE (altar) == sacrifice->arch->name ||
345 ARCH_SACRIFICE(altar) == sacrifice->name || 353 ARCH_SACRIFICE (altar) == sacrifice->name ||
346 ARCH_SACRIFICE(altar) == sacrifice->slaying || 354 ARCH_SACRIFICE (altar) == sacrifice->slaying ||
347 (!strcmp(ARCH_SACRIFICE(altar),query_base_name(sacrifice,0)))) 355 (!strcmp (ARCH_SACRIFICE (altar), query_base_name (sacrifice, 0))))
348 && NROF_SACRIFICE(altar) <= (sacrifice->nrof?sacrifice->nrof:1)) 356 && NROF_SACRIFICE (altar) <= (sacrifice->nrof ? sacrifice->nrof : 1))
349 return 1; 357 return 1;
358
350 if (strcmp (ARCH_SACRIFICE(altar), "money") == 0 359 if (strcmp (ARCH_SACRIFICE (altar), "money") == 0
351 && sacrifice->type == MONEY
352 && sacrifice->nrof * sacrifice->value >= NROF_SACRIFICE(altar)) 360 && sacrifice->type == MONEY && sacrifice->nrof * sacrifice->value >= NROF_SACRIFICE (altar))
353 return 1; 361 return 1;
354 } 362 }
363
355 return 0; 364 return 0;
356} 365}
357
358 366
359/* 367/*
360 * operate_altar checks if sacrifice was accepted and removes sacrificed 368 * operate_altar checks if sacrifice was accepted and removes sacrificed
361 * objects. If sacrifice was succeed return 1 else 0. Might be better to 369 * objects. If sacrifice was succeed return 1 else 0. Might be better to
362 * call check_altar_sacrifice (above) than depend on the return value, 370 * call check_altar_sacrifice (above) than depend on the return value,
363 * since operate_altar will remove the sacrifice also. 371 * since operate_altar will remove the sacrifice also.
364 * 372 *
365 * If this function returns 1, '*sacrifice' is modified to point to the 373 * If this function returns 1, '*sacrifice' is modified to point to the
366 * remaining sacrifice, or is set to NULL if the sacrifice was used up. 374 * remaining sacrifice, or is set to NULL if the sacrifice was used up.
367 */ 375 */
368 376int
369int operate_altar (object *altar, object **sacrifice) 377operate_altar (object *altar, object **sacrifice)
370{ 378{
371
372 if ( ! altar->map) { 379 if (!altar->map)
380 {
373 LOG (llevError, "BUG: operate_altar(): altar has no map\n"); 381 LOG (llevError, "BUG: operate_altar(): altar has no map\n");
374 return 0; 382 return 0;
375 } 383 }
376 384
377 if (!altar->slaying || altar->value) 385 if (!altar->slaying || altar->value)
378 return 0; 386 return 0;
379 387
380 if ( ! check_altar_sacrifice (altar, *sacrifice)) 388 if (!check_altar_sacrifice (altar, *sacrifice))
381 return 0; 389 return 0;
382 390
383 /* check_altar_sacrifice should have already verified that enough money 391 /* check_altar_sacrifice should have already verified that enough money
384 * has been dropped. 392 * has been dropped.
385 */ 393 */
386 if (!strcmp(ARCH_SACRIFICE(altar), "money")) { 394 if (!strcmp (ARCH_SACRIFICE (altar), "money"))
395 {
387 int number=NROF_SACRIFICE(altar) / (*sacrifice)->value; 396 int number = NROF_SACRIFICE (altar) / (*sacrifice)->value;
388 397
389 /* Round up any sacrifices. Altars don't make change either */ 398 /* Round up any sacrifices. Altars don't make change either */
390 if (NROF_SACRIFICE(altar) % (*sacrifice)->value) number++; 399 if (NROF_SACRIFICE (altar) % (*sacrifice)->value)
400 number++;
401
391 *sacrifice = decrease_ob_nr (*sacrifice, number); 402 *sacrifice = decrease_ob_nr (*sacrifice, number);
392 } 403 }
393 else 404 else
394 *sacrifice = decrease_ob_nr (*sacrifice, NROF_SACRIFICE(altar)); 405 *sacrifice = decrease_ob_nr (*sacrifice, NROF_SACRIFICE (altar));
395 406
396 if (altar->msg) 407 if (altar->msg)
397 new_info_map(NDI_BLACK, altar->map, altar->msg); 408 new_info_map (NDI_BLACK, altar->map, altar->msg);
409
398 return 1; 410 return 1;
399} 411}
400 412
413void
401void trigger_move (object *op, int state) /* 1 down and 0 up */ 414trigger_move (object *op, int state) /* 1 down and 0 up */
402{ 415{
403 op->stats.wc = state; 416 op->stats.wc = state;
404 if (state) { 417 if (state)
418 {
405 use_trigger(op); 419 use_trigger (op);
406 if (op->stats.exp > 0) /* check sanity */ 420 if (op->stats.exp > 0) /* check sanity */
407 op->speed = 1.0 / op->stats.exp; 421 op->speed = 1.0 / op->stats.exp;
408 else 422 else
409 op->speed = 1.0; 423 op->speed = 1.0;
410 update_ob_speed(op); 424 update_ob_speed (op);
411 op->speed_left = -1; 425 op->speed_left = -1;
412 } else { 426 }
427 else
428 {
413 use_trigger(op); 429 use_trigger (op);
414 op->speed = 0; 430 op->speed = 0;
415 update_ob_speed(op); 431 update_ob_speed (op);
416 } 432 }
417} 433}
418 434
419 435
420/* 436/*
… …
427 * 443 *
428 * TRIGGER: Returns 1 if handle could be moved, 0 if not. 444 * TRIGGER: Returns 1 if handle could be moved, 0 if not.
429 * 445 *
430 * TRIGGER_BUTTON, TRIGGER_PEDESTAL: Returns 0. 446 * TRIGGER_BUTTON, TRIGGER_PEDESTAL: Returns 0.
431 */ 447 */
448int
432int check_trigger (object *op, object *cause) 449check_trigger (object *op, object *cause)
433{ 450{
434 object *tmp; 451 object *tmp;
435 int push = 0, tot = 0; 452 int push = 0, tot = 0;
436 int in_movement = op->stats.wc || op->speed; 453 int in_movement = op->stats.wc || op->speed;
437 454
438 switch (op->type) { 455 switch (op->type)
456 {
439 case TRIGGER_BUTTON: 457 case TRIGGER_BUTTON:
440 if (op->weight > 0) { 458 if (op->weight > 0)
459 {
441 if (cause) { 460 if (cause)
461 {
442 for (tmp = op->above; tmp; tmp = tmp->above) 462 for (tmp = op->above; tmp; tmp = tmp->above)
443 /* Comment reproduced from update_buttons(): */ 463 /* Comment reproduced from update_buttons(): */
444 /* Basically, if the move_type matches that on what the 464 /* Basically, if the move_type matches that on what the
445 * button wants, we count it. The second check is so that 465 * button wants, we count it. The second check is so that
446 * objects that don't move (swords, etc) will count. Note that 466 * objects that don't move (swords, etc) will count. Note that
447 * this means that more work is needed to make buttons 467 * this means that more work is needed to make buttons
448 * that are only triggered by flying objects. 468 * that are only triggered by flying objects.
449 */ 469 */
450 470
451 if ((tmp->move_type & op->move_on) || tmp->move_type==0) { 471 if ((tmp->move_type & op->move_on) || tmp->move_type == 0)
472 {
452 tot += tmp->weight * (tmp->nrof ? tmp->nrof : 1) 473 tot += tmp->weight * (tmp->nrof ? tmp->nrof : 1) + tmp->carrying;
453 + tmp->carrying;
454 } 474 }
455 if (tot >= op->weight) 475 if (tot >= op->weight)
456 push = 1; 476 push = 1;
457 if (op->stats.ac == push) 477 if (op->stats.ac == push)
458 return 0; 478 return 0;
459 op->stats.ac = push; 479 op->stats.ac = push;
460 if (NUM_ANIMATIONS(op) > 1) { 480 if (NUM_ANIMATIONS (op) > 1)
481 {
461 SET_ANIMATION (op, push); 482 SET_ANIMATION (op, push);
462 update_object (op, UP_OBJ_FACE); 483 update_object (op, UP_OBJ_FACE);
463 } 484 }
464 if (in_movement || ! push) 485 if (in_movement || !push)
465 return 0; 486 return 0;
466 } 487 }
467 trigger_move (op, push); 488 trigger_move (op, push);
468 } 489 }
469 return 0; 490 return 0;
470 491
471 case TRIGGER_PEDESTAL: 492 case TRIGGER_PEDESTAL:
472 if (cause) { 493 if (cause)
494 {
473 for (tmp = op->above; tmp; tmp = tmp->above) { 495 for (tmp = op->above; tmp; tmp = tmp->above)
496 {
474 object *head = tmp->head ? tmp->head : tmp; 497 object *head = tmp->head ? tmp->head : tmp;
475 498
476 /* See comment in TRIGGER_BUTTON about move_types */ 499 /* See comment in TRIGGER_BUTTON about move_types */
477 if (((head->move_type & op->move_on) || head->move_type==0) 500 if (((head->move_type & op->move_on) || head->move_type == 0)
478 && (head->race==op->slaying ||
479 (!strcmp (op->slaying, "player") && head->type == PLAYER))) { 501 && (head->race == op->slaying || (!strcmp (op->slaying, "player") && head->type == PLAYER)))
502 {
480 push = 1; 503 push = 1;
481 break; 504 break;
482 } 505 }
483 } 506 }
484 if (op->stats.ac == push) 507 if (op->stats.ac == push)
485 return 0; 508 return 0;
486 op->stats.ac = push; 509 op->stats.ac = push;
487 if (NUM_ANIMATIONS(op) > 1) { 510 if (NUM_ANIMATIONS (op) > 1)
511 {
488 SET_ANIMATION (op, push); 512 SET_ANIMATION (op, push);
489 update_object (op, UP_OBJ_FACE); 513 update_object (op, UP_OBJ_FACE);
490 } 514 }
491 update_object(op,UP_OBJ_FACE); 515 update_object (op, UP_OBJ_FACE);
492 if (in_movement || ! push) 516 if (in_movement || !push)
493 return 0; 517 return 0;
494 } 518 }
495 trigger_move (op, push); 519 trigger_move (op, push);
496 return 0; 520 return 0;
497 521
498 case TRIGGER_ALTAR: 522 case TRIGGER_ALTAR:
499 if (cause) { 523 if (cause)
524 {
500 if (in_movement) 525 if (in_movement)
501 return 0; 526 return 0;
502 if (operate_altar (op, &cause)) { 527 if (operate_altar (op, &cause))
528 {
503 if (NUM_ANIMATIONS(op) > 1) { 529 if (NUM_ANIMATIONS (op) > 1)
530 {
504 SET_ANIMATION (op, 1); 531 SET_ANIMATION (op, 1);
505 update_object(op, UP_OBJ_FACE); 532 update_object (op, UP_OBJ_FACE);
506 } 533 }
507 if (op->last_sp >= 0) { 534 if (op->last_sp >= 0)
535 {
508 trigger_move (op, 1); 536 trigger_move (op, 1);
509 if (op->last_sp > 0) 537 if (op->last_sp > 0)
510 op->last_sp = -op->last_sp; 538 op->last_sp = -op->last_sp;
511 } 539 }
512 else { 540 else
541 {
513 /* for trigger altar with last_sp, the ON/OFF 542 /* for trigger altar with last_sp, the ON/OFF
514 * status (-> +/- value) is "simulated": 543 * status (-> +/- value) is "simulated":
515 */ 544 */
516 op->value = !op->value; 545 op->value = !op->value;
517 trigger_move (op, 1); 546 trigger_move (op, 1);
518 op->last_sp = -op->last_sp; 547 op->last_sp = -op->last_sp;
519 op->value = !op->value; 548 op->value = !op->value;
520 } 549 }
521 return cause == NULL; 550 return cause == NULL;
551 }
522 } else { 552 else
553 {
523 return 0; 554 return 0;
524 }
525 } else {
526 if (NUM_ANIMATIONS(op) > 1) {
527 SET_ANIMATION (op, 0);
528 update_object(op, UP_OBJ_FACE);
529 }
530
531 /* If trigger_altar has "last_sp > 0" set on the map,
532 * it will push the connected value only once per sacrifice.
533 * Otherwise (default), the connected value will be
534 * pushed twice: First by sacrifice, second by reset! -AV
535 */
536 if (!op->last_sp)
537 trigger_move (op, 0);
538 else {
539 op->stats.wc = 0;
540 op->value = !op->value;
541 op->speed = 0;
542 update_ob_speed(op);
543 } 555 }
544 } 556 }
557 else
558 {
559 if (NUM_ANIMATIONS (op) > 1)
560 {
561 SET_ANIMATION (op, 0);
562 update_object (op, UP_OBJ_FACE);
563 }
564
565 /* If trigger_altar has "last_sp > 0" set on the map,
566 * it will push the connected value only once per sacrifice.
567 * Otherwise (default), the connected value will be
568 * pushed twice: First by sacrifice, second by reset! -AV
569 */
570 if (!op->last_sp)
571 trigger_move (op, 0);
572 else
573 {
574 op->stats.wc = 0;
575 op->value = !op->value;
576 op->speed = 0;
577 update_ob_speed (op);
578 }
579 }
545 return 0; 580 return 0;
546 581
547 case TRIGGER: 582 case TRIGGER:
548 if (cause) { 583 if (cause)
584 {
549 if (in_movement) 585 if (in_movement)
550 return 0; 586 return 0;
551 push = 1; 587 push = 1;
552 } 588 }
553 if (NUM_ANIMATIONS(op) > 1) { 589 if (NUM_ANIMATIONS (op) > 1)
590 {
554 SET_ANIMATION (op, push); 591 SET_ANIMATION (op, push);
555 update_object(op, UP_OBJ_FACE); 592 update_object (op, UP_OBJ_FACE);
556 } 593 }
557 trigger_move (op, push); 594 trigger_move (op, push);
558 return 1; 595 return 1;
559 596
560 default: 597 default:
561 LOG(llevDebug, "Unknown trigger type: %s (%d)\n", op->name, op->type); 598 LOG (llevDebug, "Unknown trigger type: %s (%d)\n", &op->name, op->type);
562 return 0; 599 return 0;
563 } 600 }
564} 601}
565 602
603void
566void add_button_link(object *button, mapstruct *map, int connected) { 604add_button_link (object *button, maptile *map, int connected)
605{
567 oblinkpt *obp; 606 oblinkpt *obp;
568 objectlink *ol = get_objectlink(); 607 objectlink *ol = get_objectlink ();
569 608
570 if (!map) { 609 if (!map)
610 {
571 LOG(llevError, "Tried to add button-link without map.\n"); 611 LOG (llevError, "Tried to add button-link without map.\n");
572 return; 612 return;
573 } 613 }
614 if (!editor)
574 if (!editor) button->path_attuned = connected; /* peterm: I need this so I can rebuild 615 button->path_attuned = connected; /* peterm: I need this so I can rebuild
575 a connected map from a template map. */ 616 a connected map from a template map. */
617
576/* LOG(llevDebug,"adding button %s (%d)\n", button->name, connected);*/ 618/* LOG(llevDebug,"adding button %s (%d)\n", button->name, connected);*/
577 619
578 SET_FLAG(button,FLAG_IS_LINKED); 620 SET_FLAG (button, FLAG_IS_LINKED);
579 621
580 ol->ob = button; 622 ol->ob = button;
581 ol->id = button->count;
582 623
583 for (obp = map->buttons; obp && obp->value != connected; obp = obp->next); 624 for (obp = map->buttons; obp && obp->value != connected; obp = obp->next);
584 625
585 if (obp) { 626 if (obp)
627 {
586 ol->next = obp->link; 628 ol->next = obp->link;
587 obp->link = ol; 629 obp->link = ol;
630 }
588 } else { 631 else
632 {
589 obp = get_objectlinkpt(); 633 obp = get_objectlinkpt ();
590 obp->value = connected; 634 obp->value = connected;
591 635
592 obp->next = map->buttons; 636 obp->next = map->buttons;
593 map->buttons = obp; 637 map->buttons = obp;
594 obp->link = ol; 638 obp->link = ol;
595 } 639 }
596} 640}
597 641
598/* 642/*
599 * Remove the object from the linked lists of buttons in the map. 643 * Remove the object from the linked lists of buttons in the map.
600 * This is only needed by editors. 644 * This is only needed by editors.
601 */ 645 */
602 646
647void
603void remove_button_link(object *op) { 648remove_button_link (object *op)
649{
604 oblinkpt *obp; 650 oblinkpt *obp;
605 objectlink **olp, *ol; 651 objectlink **olp, *ol;
606 652
607 if (op->map == NULL) { 653 if (op->map == NULL)
654 {
608 LOG(llevError, "remove_button_link() in object without map.\n"); 655 LOG (llevError, "remove_button_link() in object without map.\n");
609 return; 656 return;
610 } 657 }
658
611 if (!QUERY_FLAG(op,FLAG_IS_LINKED)) { 659 if (!QUERY_FLAG (op, FLAG_IS_LINKED))
660 {
612 LOG(llevError, "remove_button_linked() in unlinked object.\n"); 661 LOG (llevError, "remove_button_linked() in unlinked object.\n");
613 return; 662 return;
614 } 663 }
664
615 for (obp = op->map->buttons; obp; obp = obp->next) 665 for (obp = op->map->buttons; obp; obp = obp->next)
616 for (olp = &obp->link; (ol = *olp); olp = &ol->next) 666 for (olp = &obp->link; (ol = *olp); olp = &ol->next)
617 if (ol->ob == op) { 667 if (ol->ob == op)
668 {
669
618/* LOG(llevDebug, "Removed link %d in button %s and map %s.\n", 670/* LOG(llevDebug, "Removed link %d in button %s and map %s.\n",
619 obp->value, op->name, op->map->path); 671 obp->value, op->name, op->map->path);
620*/ 672*/
621 *olp = ol->next; 673 *olp = ol->next;
622 free(ol); 674 delete ol;
623 return; 675 return;
624 } 676 }
677
625 LOG(llevError, "remove_button_linked(): couldn't find object.\n"); 678 LOG (llevError, "remove_button_linked(): couldn't find object.\n");
626 CLEAR_FLAG(op,FLAG_IS_LINKED); 679 CLEAR_FLAG (op, FLAG_IS_LINKED);
627} 680}
628 681
629/* 682/*
630 * Gets the objectlink for this connection from the map. 683 * Gets the objectlink for this connection from the map.
631 */ 684 */
685oblinkpt *
632oblinkpt *get_connection_links (mapstruct *map, long connection) 686get_connection_links (maptile *map, long connection)
633{ 687{
634 for (oblinkpt *obp = map->buttons; obp; obp = obp->next) 688 for (oblinkpt * obp = map->buttons; obp; obp = obp->next)
635 if (obp->value == connection) 689 if (obp->value == connection)
636 return obp; 690 return obp;
691
637 return 0; 692 return 0;
638} 693}
639 694
640/* 695/*
641 * Return the first objectlink in the objects linked to this one 696 * Return the first objectlink in the objects linked to this one
642 */ 697 */
643 698
699oblinkpt *
644oblinkpt *get_button_links(const object *button) { 700get_button_links (const object *button)
701{
645 oblinkpt *obp; 702 oblinkpt *obp;
646 objectlink *ol; 703 objectlink *ol;
647 704
648 if (!button->map) 705 if (!button->map)
649 return NULL; 706 return NULL;
707
650 for (obp = button->map->buttons; obp; obp = obp->next) 708 for (obp = button->map->buttons; obp; obp = obp->next)
651 for (ol = obp->link; ol; ol = ol->next) 709 for (ol = obp->link; ol; ol = ol->next)
652 if (ol->ob == button && ol->id == button->count) 710 if (ol->ob == button)
653 return obp; 711 return obp;
712
654 return NULL; 713 return NULL;
655} 714}
656 715
657/* 716/*
658 * Made as a separate function to increase efficiency 717 * Made as a separate function to increase efficiency
659 */ 718 */
660 719
720int
661int get_button_value(const object *button) { 721get_button_value (const object *button)
722{
662 oblinkpt *obp; 723 oblinkpt *obp;
663 objectlink *ol; 724 objectlink *ol;
664 725
665 if (!button->map) 726 if (!button->map)
666 return 0; 727 return 0;
667 for (obp = button->map->buttons; obp; obp = obp->next) 728 for (obp = button->map->buttons; obp; obp = obp->next)
668 for (ol = obp->link; ol; ol = ol->next) 729 for (ol = obp->link; ol; ol = ol->next)
669 if (ol->ob == button && ol->id == button->count) 730 if (ol->ob == button)
670 return obp->value; 731 return obp->value;
671 return 0; 732 return 0;
672} 733}
673 734
674/* This routine makes monsters who are 735/* This routine makes monsters who are
… …
677 * If floor is to be triggered must have 738 * If floor is to be triggered must have
678 * a speed of zero (default is 1 for all 739 * a speed of zero (default is 1 for all
679 * but the charm floor type). 740 * but the charm floor type).
680 * by b.t. thomas@nomad.astro.psu.edu 741 * by b.t. thomas@nomad.astro.psu.edu
681 */ 742 */
682 743
744void
683void do_mood_floor(object *op, object *source) { 745do_mood_floor (object *op, object *source)
746{
684 object *tmp; 747 object *tmp;
685 object *tmp2; 748 object *tmp2;
686 749
687 if (!source) 750 if (!source)
688 source = op; 751 source = op;
689 752
690 for (tmp = GET_MAP_OB(op->map, op->x, op->y); tmp; tmp=tmp->above) 753 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
691 if (QUERY_FLAG(tmp, FLAG_MONSTER)) break; 754 if (QUERY_FLAG (tmp, FLAG_MONSTER))
755 break;
692 756
693 /* doesn't effect players, and if there is a player on this space, won't also 757 /* doesn't effect players, and if there is a player on this space, won't also
694 * be a monster here. 758 * be a monster here.
695 */ 759 */
696 if (!tmp || tmp->type == PLAYER) return; 760 if (!tmp || tmp->type == PLAYER)
761 return;
697 762
698 switch(op->last_sp) { 763 switch (op->last_sp)
764 {
699 case 0: /* furious--make all monsters mad */ 765 case 0: /* furious--make all monsters mad */
700 if(QUERY_FLAG(tmp, FLAG_UNAGGRESSIVE))
701 CLEAR_FLAG(tmp, FLAG_UNAGGRESSIVE);
702 if(QUERY_FLAG(tmp, FLAG_FRIENDLY)) {
703 CLEAR_FLAG(tmp, FLAG_FRIENDLY);
704 remove_friendly_object(tmp);
705 tmp->attack_movement = 0;
706 /* lots of checks here, but want to make sure we don't
707 * dereference a null value
708 */
709 if (tmp->type == GOLEM && tmp->owner && tmp->owner->type==PLAYER &&
710 tmp->owner->contr->ranges[range_golem]==tmp) {
711 tmp->owner->contr->ranges[range_golem]=NULL;
712 tmp->owner->contr->golem_count = 0;
713 }
714 tmp->owner = 0;
715 }
716 break;
717 case 1: /* angry -- get neutral monsters mad */
718 if(QUERY_FLAG(tmp, FLAG_UNAGGRESSIVE)&& 766 if (QUERY_FLAG (tmp, FLAG_UNAGGRESSIVE))
719 !QUERY_FLAG(tmp, FLAG_FRIENDLY))
720 CLEAR_FLAG(tmp, FLAG_UNAGGRESSIVE); 767 CLEAR_FLAG (tmp, FLAG_UNAGGRESSIVE);
768 if (QUERY_FLAG (tmp, FLAG_FRIENDLY))
769 {
770 CLEAR_FLAG (tmp, FLAG_FRIENDLY);
771 remove_friendly_object (tmp);
772 tmp->attack_movement = 0;
773 /* lots of checks here, but want to make sure we don't
774 * dereference a null value
775 */
776 if (tmp->type == GOLEM && tmp->owner && tmp->owner->type == PLAYER && tmp->owner->contr->ranges[range_golem] == tmp)
777 tmp->owner->contr->ranges[range_golem] = 0;
778
779 tmp->owner = 0;
780 }
721 break; 781 break;
782 case 1: /* angry -- get neutral monsters mad */
783 if (QUERY_FLAG (tmp, FLAG_UNAGGRESSIVE) && !QUERY_FLAG (tmp, FLAG_FRIENDLY))
784 CLEAR_FLAG (tmp, FLAG_UNAGGRESSIVE);
785 break;
722 case 2: /* calm -- pacify unfriendly monsters */ 786 case 2: /* calm -- pacify unfriendly monsters */
723 if(!QUERY_FLAG(tmp, FLAG_UNAGGRESSIVE)) 787 if (!QUERY_FLAG (tmp, FLAG_UNAGGRESSIVE))
724 SET_FLAG(tmp, FLAG_UNAGGRESSIVE); 788 SET_FLAG (tmp, FLAG_UNAGGRESSIVE);
789 break;
790 case 3: /* make all monsters fall asleep */
791 if (!QUERY_FLAG (tmp, FLAG_SLEEP))
792 SET_FLAG (tmp, FLAG_SLEEP);
793 break;
794 case 4: /* charm all monsters */
795 if (op == source)
796 break; /* only if 'connected' */
797
798 for (tmp2 = GET_MAP_OB (source->map, source->x, source->y); /* finding an owner */
799 tmp2->type != PLAYER; tmp2 = tmp2->above)
800 if (tmp2->above == NULL)
725 break; 801 break;
726 case 3: /* make all monsters fall asleep */
727 if(!QUERY_FLAG(tmp, FLAG_SLEEP))
728 SET_FLAG(tmp, FLAG_SLEEP);
729 break;
730 case 4: /* charm all monsters */
731 if (op == source) break; /* only if 'connected' */
732 802
733 for(tmp2=get_map_ob(source->map,source->x,source->y); /* finding an owner */
734 tmp2->type!=PLAYER;tmp2=tmp2->above)
735 if(tmp2->above==NULL) break;
736
737 if (tmp2->type != PLAYER) 803 if (tmp2->type != PLAYER)
738 break; 804 break;
739 set_owner(tmp,tmp2); 805
806 tmp->set_owner (tmp2);
740 SET_FLAG(tmp,FLAG_MONSTER); 807 SET_FLAG (tmp, FLAG_MONSTER);
808
741 tmp->stats.exp = 0; 809 tmp->stats.exp = 0;
742 SET_FLAG(tmp, FLAG_FRIENDLY); 810 SET_FLAG (tmp, FLAG_FRIENDLY);
811
743 add_friendly_object (tmp); 812 add_friendly_object (tmp);
744 tmp->attack_movement = PETMOVE; 813 tmp->attack_movement = PETMOVE;
745 break; 814 break;
746 815
747 default: 816 default:
748 break; 817 break;
749
750 } 818 }
751} 819}
752 820
753/* this function returns the object it matches, or NULL if non. 821/* this function returns the object it matches, or NULL if non.
754 * It will descend through containers to find the object. 822 * It will descend through containers to find the object.
755 * slaying = match object slaying flag 823 * slaying = match object slaying flag
756 * race = match object archetype name flag 824 * race = match object archetype name flag
757 * hp = match object type (excpt type '0'== PLAYER) 825 * hp = match object type (excpt type '0'== PLAYER)
758 */ 826 */
759 827object *
760object * check_inv_recursive(object *op, const object *trig) 828check_inv_recursive (object *op, const object *trig)
761{ 829{
762 object *tmp,*ret=NULL; 830 object *tmp, *ret = NULL;
763 831
764 /* First check the object itself. */ 832 /* First check the object itself. */
765 if((trig->stats.hp && (op->type == trig->stats.hp)) 833 if ((trig->stats.hp && (op->type == trig->stats.hp))
766 || (trig->slaying && (op->slaying == trig->slaying)) 834 || (trig->slaying && (op->slaying == trig->slaying))
767 || (trig->race && (op->arch->name == trig->race))) 835 || (trig->race && (op->arch->name == trig->race)))
768 return op; 836 return op;
769 837
770 for(tmp=op->inv; tmp; tmp=tmp->below) { 838 for (tmp = op->inv; tmp; tmp = tmp->below)
839 {
771 if (tmp->inv) { 840 if (tmp->inv)
841 {
772 ret=check_inv_recursive(tmp, trig); 842 ret = check_inv_recursive (tmp, trig);
843 if (ret)
773 if (ret) return ret; 844 return ret;
774 } 845 }
775 else if((trig->stats.hp && (tmp->type == trig->stats.hp)) 846 else if ((trig->stats.hp && (tmp->type == trig->stats.hp))
776 || (trig->slaying && (tmp->slaying == trig->slaying)) 847 || (trig->slaying && (tmp->slaying == trig->slaying))
777 || (trig->race && (tmp->arch->name == trig->race))) 848 || (trig->race && (tmp->arch->name == trig->race)))
778 return tmp; 849 return tmp;
779 } 850 }
780 return NULL; 851 return NULL;
781} 852}
782 853
783/* check_inv(), a function to search the inventory, 854/* check_inv(), a function to search the inventory,
784 * of a player and then based on a set of conditions, 855 * of a player and then based on a set of conditions,
785 * the square will activate connected items. 856 * the square will activate connected items.
786 * Monsters can't trigger this square (for now) 857 * Monsters can't trigger this square (for now)
787 * Values are: last_sp = 1/0 obj/no obj triggers 858 * Values are: last_sp = 1/0 obj/no obj triggers
788 * last_heal = 1/0 remove/dont remove obj if triggered 859 * last_heal = 1/0 remove/dont remove obj if triggered
789 * -b.t. (thomas@nomad.astro.psu.edu 860 * -b.t. (thomas@nomad.astro.psu.edu
790 */ 861 *
791 862 * Tue Dec 19 15:34:00 CET 2006 elmex: changed the function to ignore op
863 * because the check-inventory semantic essentially only applies when
864 * something is above the inventory checker.
865 * The semantic prior this change was: trigger if something has moved on or off
866 * and has a matching item. Imagine what happens if someone steps on the inventory
867 * checker with a matching item, has it, activates the connection, throws the item
868 * away, and then leaves the inventory checker. That would've caused an always-enabled
869 * state in the inventory checker. This won't happen anymore now.
870 *
871 */
872void
792void check_inv (object *op, object *trig) { 873check_inv (object *op, object *trig)
793object *match; 874{
875 trig->value = 0; // deactivate if none of the following conditions apply
794 876
795 if(op->type != PLAYER) return; 877 if (object *pl = trig->ms ().player ())
878 {
796 match = check_inv_recursive(op,trig); 879 object *match = check_inv_recursive (pl, trig);
880
797 if (match && trig->last_sp) { 881 if (match && trig->last_sp) // match == having
882 {
798 if(trig->last_heal) 883 if (trig->last_heal)
799 decrease_ob(match); 884 decrease_ob (match);
800 use_trigger(trig);
801 }
802 else if (!match && !trig->last_sp)
803 use_trigger(trig);
804}
805 885
806 886 trig->value = 1;
807/* This does a minimal check of the button link consistency for object
808 * map. All it really does it much sure the object id link that is set
809 * matches what the object has.
810 */
811void verify_button_links(const mapstruct *map) {
812 oblinkpt *obp;
813 objectlink *ol;
814
815 if (!map) return;
816
817 for (obp = map->buttons; obp; obp = obp->next) {
818 for (ol=obp->link; ol; ol=ol->next) {
819 if (ol->id!=ol->ob->count)
820 LOG(llevError,"verify_button_links: object %s on list is corrupt (%d!=%d)\n",ol->ob->name, ol->id, ol->ob->count);
821 } 887 }
888 else if (!match && !trig->last_sp) // match == not having
889 trig->value = 1;
822 } 890 }
891
892 push_button (trig);
823} 893}
894

Diff Legend

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