Crossfire Server, Trunk
treasure.cpp
Go to the documentation of this file.
1 /*
2  * Crossfire -- cooperative multi-player graphical RPG and adventure game
3  *
4  * Copyright (c) 1999-2014 Mark Wedel and the Crossfire Development Team
5  * Copyright (c) 1992 Frank Tore Johansen
6  *
7  * Crossfire is free software and comes with ABSOLUTELY NO WARRANTY. You are
8  * welcome to redistribute it under certain conditions. For details, please
9  * see COPYING and LICENSE.
10  *
11  * The authors can be reached via e-mail at <crossfire@metalforge.org>.
12  */
13 
20 #include "global.h"
21 
22 #include <ctype.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <math.h>
26 
27 #include "loader.h"
28 #include "sproto.h"
29 #include "treasure.h"
30 #include "assets.h"
31 #include "AssetsManager.h"
32 
39 static int resist_table[] = {
45 };
46 
50 static archetype *ring_arch = NULL, *amulet_arch = NULL, *crown_arch = NULL;
51 
53 #define num_resist_table 19
54 
55 static void change_treasure(treasure *t, object *op); /* overrule default values */
56 static int special_potion(object *op);
57 static void fix_flesh_item(object *item, const object *donor);
58 
63  if (ring_arch == NULL)
64  ring_arch = find_archetype("ring");
65  if (amulet_arch == NULL)
66  amulet_arch = find_archetype("amulet");
67  if (crown_arch == NULL)
68  crown_arch = find_archetype("crown");
69 }
70 
82 static void put_treasure(object *op, object *creator, int flags) {
83  /* Bit of a hack - spells should never be put onto the map. The entire
84  * treasure stuff is a problem - there is no clear idea of knowing
85  * this is the original object, or if this is an object that should be created
86  * by another object.
87  */
88  if (flags&GT_ENVIRONMENT && op->type != SPELL) {
90  object_insert_in_map_at(op, creator->map, op, INS_NO_MERGE|INS_NO_WALK_ON, creator->x, creator->y);
91  } else
92  object_insert_in_ob(op, creator);
93 }
94 
105 static void change_treasure(treasure *t, object *op) {
106  /* CMD: change_name xxxx */
107  if (t->change_arch.name) {
108  FREE_AND_COPY(op->name, t->change_arch.name);
109  /* not great, but better than something that is completely wrong */
110  FREE_AND_COPY(op->name_pl, t->change_arch.name);
111  }
112 
113  if (t->change_arch.title) {
114  if (op->title)
115  free_string(op->title);
116  op->title = add_string(t->change_arch.title);
117  }
118 
119  if (t->change_arch.slaying) {
120  if (op->slaying)
121  free_string(op->slaying);
122  op->slaying = add_string(t->change_arch.slaying);
123  }
124 }
125 
139 static void do_single_item(treasure *t, object *op, int flag, int difficulty) {
140  if (t->item && (t->item->clone.invisible != 0 || !(flag&GT_INVISIBLE))) {
141  object *tmp = arch_to_object(t->item);
142  if (t->nrof && tmp->nrof <= 1)
143  tmp->nrof = RANDOM()%((int)t->nrof)+1;
144  if (t->artifact) {
145  const artifact *art = find_artifact(tmp, t->artifact);
146  if (!art || !legal_artifact_combination(tmp, art)) {
147  LOG(llevError, "Invalid artifact %s for treasure %s\n", t->artifact, tmp->arch->name);
149  return;
150  }
152  } else {
153  fix_generated_item(tmp, op, difficulty, t->magic, flag);
155  }
156  put_treasure(tmp, op, flag);
157  }
158 }
159 
175 static void create_all_treasures(treasure *t, object *op, int flag, int difficulty, int tries) {
176  if ((int)t->chance >= 100 || (RANDOM()%100+1) < t->chance) {
177  if (t->name) {
178  if (strcmp(t->name, "NONE") && difficulty >= t->magic)
179  create_treasure(find_treasurelist(t->name), op, flag, t->list_magic_value ? t->list_magic_value : difficulty + t->list_magic_adjustment, tries);
180  } else {
181  do_single_item(t, op, flag, difficulty);
182  }
183  if (t->next_yes != NULL)
184  create_all_treasures(t->next_yes, op, flag, difficulty, tries);
185  } else
186  if (t->next_no != NULL)
187  create_all_treasures(t->next_no, op, flag, difficulty, tries);
188  if (t->next != NULL)
189  create_all_treasures(t->next, op, flag, difficulty, tries);
190 }
191 
210 static void create_one_treasure(treasurelist *tl, object *op, int flag, int difficulty, int tries) {
211  int value = RANDOM()%tl->total_chance;
212  treasure *t;
213 
214  if (tries++ > 100) {
215  LOG(llevDebug, "create_one_treasure: tries exceeded 100, returning without making treasure\n");
216  return;
217  }
218 
219  for (t = tl->items; t != NULL; t = t->next) {
220  value -= t->chance;
221  if (value < 0)
222  break;
223  }
224 
225  if (!t || value >= 0) {
226  LOG(llevError, "create_one_treasure: got null object or not able to find treasure\n");
227  abort();
228  }
229  if (t->name) {
230  if (!strcmp(t->name, "NONE"))
231  return;
232  if (difficulty >= t->magic)
233  create_treasure(find_treasurelist(t->name), op, flag, t->list_magic_value ? t->list_magic_value : difficulty + t->list_magic_adjustment, tries);
234  else if (t->nrof)
235  create_one_treasure(tl, op, flag, difficulty, tries);
236  return;
237  }
238  if ((t->item) && (flag&GT_ONLY_GOOD)) { /* Generate only good items, damnit !*/
239  if (QUERY_FLAG(&(t->item->clone), FLAG_CURSED)
240  || QUERY_FLAG(&(t->item->clone), FLAG_DAMNED)) {
241  create_one_treasure(tl, op, flag, difficulty, tries+1);
242  return;
243  }
244  }
245  do_single_item(t, op, flag, difficulty);
246 }
247 
263 void create_treasure(treasurelist *t, object *op, int flag, int difficulty, int tries) {
264  if (tries++ > 100) {
265  LOG(llevDebug, "createtreasure: tries exceeded 100, returning without making treasure\n");
266  return;
267  }
268  if (!t->items) {
269  LOG(llevError, "Empty treasure list %s\n", t->name);
270  return;
271  }
272  if (t->total_chance)
273  create_one_treasure(t, op, flag, difficulty, tries);
274  else
275  create_all_treasures(t->items, op, flag, difficulty, tries);
276 }
277 
295 object *generate_treasure(treasurelist *t, int difficulty) {
296  object *ob = object_new(), *tmp;
297 
298  create_treasure(t, ob, 0, difficulty, 0);
299 
300  /* Don't want to free the object we are about to return */
301  tmp = ob->inv;
302  if (tmp != NULL)
304  if (ob->inv) {
305  LOG(llevError, "In generate treasure, created multiple objects.\n");
306  }
308  return tmp;
309 }
310 
323 static int level_for_item(const object *op, int difficulty) {
324  int level, mult, olevel;
325 
326  if (!op->inv) {
327  LOG(llevError, "level_for_item: Object %s has no inventory!\n", op->name);
328  return 0;
329  }
330  level = op->inv->level;
331 
332  /* Basically, we set mult to the lowest spell increase attribute that is
333  * not zero - zero's mean no modification is done, so we don't want those.
334  * given we want non zero results, we can't just use a few MIN's here.
335  */
336  mult = op->inv->dam_modifier;
337  if (op->inv->range_modifier && (op->inv->range_modifier < mult || mult == 0))
338  mult = op->inv->range_modifier;
339  if (op->inv->duration_modifier && (op->inv->duration_modifier < mult || mult == 0))
340  mult = op->inv->duration_modifier;
341 
342  if (mult == 0)
343  mult = 5;
344 
345  olevel = mult*rndm(0, difficulty)+level;
346  if (olevel > MAX_SPELLITEM_LEVEL)
347  olevel = MAX_SPELLITEM_LEVEL;
348 
349  return olevel;
350 }
351 
359 static const int difftomagic_list[DIFFLEVELS][MAXMAGIC+1] = {
360 /*chance of magic difficulty*/
361 /* +0 +1 +2 +3 +4 */
362  { 94, 3, 2, 1, 0 }, /*1*/
363  { 94, 3, 2, 1, 0 }, /*2*/
364  { 94, 3, 2, 1, 0 }, /*3*/
365  { 94, 3, 2, 1, 0 }, /*4*/
366  { 94, 3, 2, 1, 0 }, /*5*/
367  { 90, 4, 3, 2, 1 }, /*6*/
368  { 90, 4, 3, 2, 1 }, /*7*/
369  { 90, 4, 3, 2, 1 }, /*8*/
370  { 90, 4, 3, 2, 1 }, /*9*/
371  { 90, 4, 3, 2, 1 }, /*10*/
372  { 85, 6, 4, 3, 2 }, /*11*/
373  { 85, 6, 4, 3, 2 }, /*12*/
374  { 85, 6, 4, 3, 2 }, /*13*/
375  { 85, 6, 4, 3, 2 }, /*14*/
376  { 85, 6, 4, 3, 2 }, /*15*/
377  { 81, 8, 5, 4, 3 }, /*16*/
378  { 81, 8, 5, 4, 3 }, /*17*/
379  { 81, 8, 5, 4, 3 }, /*18*/
380  { 81, 8, 5, 4, 3 }, /*19*/
381  { 81, 8, 5, 4, 3 }, /*20*/
382  { 75, 10, 6, 5, 4 }, /*21*/
383  { 75, 10, 6, 5, 4 }, /*22*/
384  { 75, 10, 6, 5, 4 }, /*23*/
385  { 75, 10, 6, 5, 4 }, /*24*/
386  { 75, 10, 6, 5, 4 }, /*25*/
387  { 70, 12, 7, 6, 5 }, /*26*/
388  { 70, 12, 7, 6, 5 }, /*27*/
389  { 70, 12, 7, 6, 5 }, /*28*/
390  { 70, 12, 7, 6, 5 }, /*29*/
391  { 70, 12, 7, 6, 5 }, /*30*/
392  { 70, 9, 8, 7, 6 }, /*31*/
393  { 70, 9, 8, 7, 6 }, /*32*/
394  { 70, 9, 8, 7, 6 }, /*33*/
395  { 70, 9, 8, 7, 6 }, /*34*/
396  { 70, 9, 8, 7, 6 }, /*35*/
397  { 70, 6, 9, 8, 7 }, /*36*/
398  { 70, 6, 9, 8, 7 }, /*37*/
399  { 70, 6, 9, 8, 7 }, /*38*/
400  { 70, 6, 9, 8, 7 }, /*39*/
401  { 70, 6, 9, 8, 7 }, /*40*/
402  { 70, 3, 10, 9, 8 }, /*41*/
403  { 70, 3, 10, 9, 8 }, /*42*/
404  { 70, 3, 10, 9, 8 }, /*43*/
405  { 70, 3, 10, 9, 8 }, /*44*/
406  { 70, 3, 10, 9, 8 }, /*45*/
407  { 70, 2, 9, 10, 9 }, /*46*/
408  { 70, 2, 9, 10, 9 }, /*47*/
409  { 70, 2, 9, 10, 9 }, /*48*/
410  { 70, 2, 9, 10, 9 }, /*49*/
411  { 70, 2, 9, 10, 9 }, /*50*/
412  { 70, 2, 7, 11, 10 }, /*51*/
413  { 70, 2, 7, 11, 10 }, /*52*/
414  { 70, 2, 7, 11, 10 }, /*53*/
415  { 70, 2, 7, 11, 10 }, /*54*/
416  { 70, 2, 7, 11, 10 }, /*55*/
417  { 70, 2, 5, 12, 11 }, /*56*/
418  { 70, 2, 5, 12, 11 }, /*57*/
419  { 70, 2, 5, 12, 11 }, /*58*/
420  { 70, 2, 5, 12, 11 }, /*59*/
421  { 70, 2, 5, 12, 11 }, /*60*/
422  { 70, 2, 3, 13, 12 }, /*61*/
423  { 70, 2, 3, 13, 12 }, /*62*/
424  { 70, 2, 3, 13, 12 }, /*63*/
425  { 70, 2, 3, 13, 12 }, /*64*/
426  { 70, 2, 3, 13, 12 }, /*65*/
427  { 70, 2, 3, 12, 13 }, /*66*/
428  { 70, 2, 3, 12, 13 }, /*67*/
429  { 70, 2, 3, 12, 13 }, /*68*/
430  { 70, 2, 3, 12, 13 }, /*69*/
431  { 70, 2, 3, 12, 13 }, /*70*/
432  { 70, 2, 3, 11, 14 }, /*71*/
433  { 70, 2, 3, 11, 14 }, /*72*/
434  { 70, 2, 3, 11, 14 }, /*73*/
435  { 70, 2, 3, 11, 14 }, /*74*/
436  { 70, 2, 3, 11, 14 }, /*75*/
437  { 70, 2, 3, 10, 15 }, /*76*/
438  { 70, 2, 3, 10, 15 }, /*77*/
439  { 70, 2, 3, 10, 15 }, /*78*/
440  { 70, 2, 3, 10, 15 }, /*79*/
441  { 70, 2, 3, 10, 15 }, /*80*/
442  { 70, 2, 3, 9, 16 }, /*81*/
443  { 70, 2, 3, 9, 16 }, /*82*/
444  { 70, 2, 3, 9, 16 }, /*83*/
445  { 70, 2, 3, 9, 16 }, /*84*/
446  { 70, 2, 3, 9, 16 }, /*85*/
447  { 70, 2, 3, 8, 17 }, /*86*/
448  { 70, 2, 3, 8, 17 }, /*87*/
449  { 70, 2, 3, 8, 17 }, /*88*/
450  { 70, 2, 3, 8, 17 }, /*89*/
451  { 70, 2, 3, 8, 17 }, /*90*/
452  { 70, 2, 3, 7, 18 }, /*91*/
453  { 70, 2, 3, 7, 18 }, /*92*/
454  { 70, 2, 3, 7, 18 }, /*93*/
455  { 70, 2, 3, 7, 18 }, /*94*/
456  { 70, 2, 3, 7, 18 }, /*95*/
457  { 70, 2, 3, 6, 19 }, /*96*/
458  { 70, 2, 3, 6, 19 }, /*97*/
459  { 70, 2, 3, 6, 19 }, /*98*/
460  { 70, 2, 3, 6, 19 }, /*99*/
461  { 70, 2, 3, 6, 19 }, /*100*/
462  { 70, 2, 3, 6, 19 }, /*101*/
463  { 70, 2, 3, 6, 19 }, /*101*/
464  { 70, 2, 3, 6, 19 }, /*102*/
465  { 70, 2, 3, 6, 19 }, /*103*/
466  { 70, 2, 3, 6, 19 }, /*104*/
467  { 70, 2, 3, 6, 19 }, /*105*/
468  { 70, 2, 3, 6, 19 }, /*106*/
469  { 70, 2, 3, 6, 19 }, /*107*/
470  { 70, 2, 3, 6, 19 }, /*108*/
471  { 70, 2, 3, 6, 19 }, /*109*/
472  { 70, 2, 3, 6, 19 }, /*110*/
473  { 70, 2, 3, 6, 19 }, /*111*/
474  { 70, 2, 3, 6, 19 }, /*112*/
475  { 70, 2, 3, 6, 19 }, /*113*/
476  { 70, 2, 3, 6, 19 }, /*114*/
477  { 70, 2, 3, 6, 19 }, /*115*/
478  { 70, 2, 3, 6, 19 }, /*116*/
479  { 70, 2, 3, 6, 19 }, /*117*/
480  { 70, 2, 3, 6, 19 }, /*118*/
481  { 70, 2, 3, 6, 19 }, /*119*/
482  { 70, 2, 3, 6, 19 }, /*120*/
483  { 70, 2, 3, 6, 19 }, /*121*/
484  { 70, 2, 3, 6, 19 }, /*122*/
485  { 70, 2, 3, 6, 19 }, /*123*/
486  { 70, 2, 3, 6, 19 }, /*124*/
487  { 70, 2, 3, 6, 19 }, /*125*/
488  { 70, 2, 3, 6, 19 }, /*126*/
489  { 70, 2, 3, 6, 19 }, /*127*/
490  { 70, 2, 3, 6, 19 }, /*128*/
491  { 70, 2, 3, 6, 19 }, /*129*/
492  { 70, 2, 3, 6, 19 }, /*130*/
493  { 70, 2, 3, 6, 19 }, /*131*/
494  { 70, 2, 3, 6, 19 }, /*132*/
495  { 70, 2, 3, 6, 19 }, /*133*/
496  { 70, 2, 3, 6, 19 }, /*134*/
497  { 70, 2, 3, 6, 19 }, /*135*/
498  { 70, 2, 3, 6, 19 }, /*136*/
499  { 70, 2, 3, 6, 19 }, /*137*/
500  { 70, 2, 3, 6, 19 }, /*138*/
501  { 70, 2, 3, 6, 19 }, /*139*/
502  { 70, 2, 3, 6, 19 }, /*140*/
503  { 70, 2, 3, 6, 19 }, /*141*/
504  { 70, 2, 3, 6, 19 }, /*142*/
505  { 70, 2, 3, 6, 19 }, /*143*/
506  { 70, 2, 3, 6, 19 }, /*144*/
507  { 70, 2, 3, 6, 19 }, /*145*/
508  { 70, 2, 3, 6, 19 }, /*146*/
509  { 70, 2, 3, 6, 19 }, /*147*/
510  { 70, 2, 3, 6, 19 }, /*148*/
511  { 70, 2, 3, 6, 19 }, /*149*/
512  { 70, 2, 3, 6, 19 }, /*150*/
513  { 70, 2, 3, 6, 19 }, /*151*/
514  { 70, 2, 3, 6, 19 }, /*152*/
515  { 70, 2, 3, 6, 19 }, /*153*/
516  { 70, 2, 3, 6, 19 }, /*154*/
517  { 70, 2, 3, 6, 19 }, /*155*/
518  { 70, 2, 3, 6, 19 }, /*156*/
519  { 70, 2, 3, 6, 19 }, /*157*/
520  { 70, 2, 3, 6, 19 }, /*158*/
521  { 70, 2, 3, 6, 19 }, /*159*/
522  { 70, 2, 3, 6, 19 }, /*160*/
523  { 70, 2, 3, 6, 19 }, /*161*/
524  { 70, 2, 3, 6, 19 }, /*162*/
525  { 70, 2, 3, 6, 19 }, /*163*/
526  { 70, 2, 3, 6, 19 }, /*164*/
527  { 70, 2, 3, 6, 19 }, /*165*/
528  { 70, 2, 3, 6, 19 }, /*166*/
529  { 70, 2, 3, 6, 19 }, /*167*/
530  { 70, 2, 3, 6, 19 }, /*168*/
531  { 70, 2, 3, 6, 19 }, /*169*/
532  { 70, 2, 3, 6, 19 }, /*170*/
533  { 70, 2, 3, 6, 19 }, /*171*/
534  { 70, 2, 3, 6, 19 }, /*172*/
535  { 70, 2, 3, 6, 19 }, /*173*/
536  { 70, 2, 3, 6, 19 }, /*174*/
537  { 70, 2, 3, 6, 19 }, /*175*/
538  { 70, 2, 3, 6, 19 }, /*176*/
539  { 70, 2, 3, 6, 19 }, /*177*/
540  { 70, 2, 3, 6, 19 }, /*178*/
541  { 70, 2, 3, 6, 19 }, /*179*/
542  { 70, 2, 3, 6, 19 }, /*180*/
543  { 70, 2, 3, 6, 19 }, /*181*/
544  { 70, 2, 3, 6, 19 }, /*182*/
545  { 70, 2, 3, 6, 19 }, /*183*/
546  { 70, 2, 3, 6, 19 }, /*184*/
547  { 70, 2, 3, 6, 19 }, /*185*/
548  { 70, 2, 3, 6, 19 }, /*186*/
549  { 70, 2, 3, 6, 19 }, /*187*/
550  { 70, 2, 3, 6, 19 }, /*188*/
551  { 70, 2, 3, 6, 19 }, /*189*/
552  { 70, 2, 3, 6, 19 }, /*190*/
553  { 70, 2, 3, 6, 19 }, /*191*/
554  { 70, 2, 3, 6, 19 }, /*192*/
555  { 70, 2, 3, 6, 19 }, /*193*/
556  { 70, 2, 3, 6, 19 }, /*194*/
557  { 70, 2, 3, 6, 19 }, /*195*/
558  { 70, 2, 3, 6, 19 }, /*196*/
559  { 70, 2, 3, 6, 19 }, /*197*/
560  { 70, 2, 3, 6, 19 }, /*198*/
561  { 70, 2, 3, 6, 19 }, /*199*/
562  { 70, 2, 3, 6, 19 }, /*200*/
563 };
564 
572 static int magic_from_difficulty(int difficulty) {
573  int percent, loop;
574 
575  difficulty--;
576  if (difficulty < 0)
577  difficulty = 0;
578 
579  if (difficulty >= DIFFLEVELS)
580  difficulty = DIFFLEVELS-1;
581 
582  percent = RANDOM()%100;
583 
584  for (loop = 0; loop < (MAXMAGIC+1); ++loop) {
585  percent -= difftomagic_list[difficulty][loop];
586  if (percent < 0)
587  break;
588  }
589  if (loop == (MAXMAGIC+1)) {
590  LOG(llevError, "Warning, table for difficulty %d bad.\n", difficulty);
591  loop = 0;
592  }
593  /* LOG(llevDebug, "Chose magic %d for difficulty %d\n", loop, difficulty);*/
594  return (RANDOM()%3) ? loop : -loop;
595 }
596 
612 void set_abs_magic(object *op, int magic) {
613  int32_t base_weight, base_speed;
614  if (!magic)
615  return;
616 
617  op->magic = magic;
618  if (op->arch) {
619  base_weight = op->arch->clone.weight;
620  base_speed = ARMOUR_SPEED(&op->arch->clone);
621  }
622  else {
623  base_weight = op->weight;
624  base_speed = ARMOUR_SPEED(op);
625  }
626  // Now we do the calculations
627  if (op->type == ARMOUR) {
629  ARMOUR_SPEED(op) = base_speed*(100+magic*settings.armor_speed_improvement)/100;
630  else
631  // This could have been done with a loop, but that seems to be less scalable.
632  // This will introduce less roundoff error than a loop, anyway
633  ARMOUR_SPEED(op) = (int32_t)(base_speed * pow(((float)(100+settings.armor_speed_improvement))/100, magic));
634  }
635  // Prepare for handling the weight. Sometimes cursed ones will have low weight like good ones.
636  if (magic < 0 && !(RANDOM()%3)) /* You can't just check the weight always */
637  magic = (-magic);
639  op->weight = (base_weight*(100-magic*settings.armor_weight_reduction))/100;
640  else
641  op->weight = (int32_t)(base_weight * pow(((float)(100-settings.armor_weight_reduction))/100, magic));
642 
643 }
644 
660 static void set_magic(int difficulty, object *op, int max_magic, int flags) {
661  int i;
662 
663  i = magic_from_difficulty(difficulty);
664  if ((flags&GT_ONLY_GOOD) && i < 0)
665  i = -i;
666  if (i > max_magic)
667  i = max_magic;
668  set_abs_magic(op, i);
669  if (i < 0)
671 }
672 
689 static void set_ring_bonus(object *op, int bonus) {
690  int r = RANDOM()%(bonus > 0 ? 25 : 11);
691 
692  if (op->type == AMULET) {
693  if (!(RANDOM()%21))
694  r = 20+RANDOM()%2;
695  else {
696  if (RANDOM()&2)
697  r = 10;
698  else
699  r = 11+RANDOM()%9;
700  }
701  }
702 
703  switch (r) {
704  /* Redone by MSW 2000-11-26 to have much less code. Also,
705  * bonuses and penalties will stack and add to existing values.
706  * of the item.
707  */
708  case 0:
709  case 1:
710  case 2:
711  case 3:
712  case 4:
713  case 5:
714  case 6:
715  set_attr_value(&op->stats, r, (signed char)(bonus+get_attr_value(&op->stats, r)));
716  break;
717 
718  case 7:
719  op->stats.dam += bonus;
720  break;
721 
722  case 8:
723  op->stats.wc += bonus;
724  break;
725 
726  case 9:
727  op->stats.food += bonus; /* hunger/sustenance */
728  break;
729 
730  case 10:
731  op->stats.ac += bonus;
732  break;
733 
734  /* Item that gives protections/vulnerabilities */
735  case 11:
736  case 12:
737  case 13:
738  case 14:
739  case 15:
740  case 16:
741  case 17:
742  case 18:
743  case 19: {
744  int b = 5+FABS(bonus), val, resist = RANDOM()%num_resist_table;
745 
746  /* Roughly generate a bonus between 100 and 35 (depending on the bonus) */
747  val = 10+RANDOM()%b+RANDOM()%b+RANDOM()%b+RANDOM()%b;
748 
749  /* Cursed items need to have higher negative values to equal out with
750  * positive values for how protections work out. Put another
751  * little random element in since that they don't always end up with
752  * even values.
753  */
754  if (bonus < 0)
755  val = 2*-val-RANDOM()%b;
756  if (val > 35)
757  val = 35; /* Upper limit */
758  b = 0;
759  while (op->resist[resist_table[resist]] != 0 && b++ < 4) {
760  resist = RANDOM()%num_resist_table;
761  }
762  if (b == 4)
763  return; /* Not able to find a free resistance */
764  op->resist[resist_table[resist]] = val;
765  /* We should probably do something more clever here to adjust value
766  * based on how good a resistance we gave.
767  */
768  break;
769  }
770 
771  case 20:
772  if (op->type == AMULET) {
774  op->value *= 11;
775  } else {
776  op->stats.hp = 1; /* regenerate hit points */
777  op->value *= 4;
778  }
779  break;
780 
781  case 21:
782  if (op->type == AMULET) {
784  op->value *= 9;
785  } else {
786  op->stats.sp = 1; /* regenerate spell points */
787  op->value *= 3;
788  }
789  break;
790 
791  case 22:
792  op->stats.grace += bonus; /* regenerate grace */
793  op->value *= 5;
794  break;
795 
796  case 23:
797  op->stats.exp += bonus; /* Speed! */
798  op->value = (op->value*2)/3;
799  break;
800  }
801  if (bonus > 0)
802  op->value *= 2*bonus;
803  else
804  op->value = -(op->value*2*bonus)/3;
805 }
806 
815 static int get_magic(int diff) {
816  int i;
817 
818  if (diff < 3)
819  diff = 3;
820  for (i = 0; i < 4; i++)
821  if (RANDOM()%diff)
822  return i;
823  return 4;
824 }
825 
836 static void trap_adjust(object *trap, int difficulty) {
837  int i;
838 
839  /* now we set the trap level to match the difficulty of the level
840  * the formula below will give a level from 1 to (2*difficulty) with
841  * a peak probability at difficulty
842  */
843 
844  trap->level = rndm(0, difficulty-1)+rndm(0, difficulty-1);
845  if (trap->level < 1)
846  trap->level = 1;
847 
848  /* set the hiddenness of the trap, similar formula to above */
849  trap->stats.Cha = rndm(0, 19)+rndm(0, difficulty-1)+rndm(0, difficulty-1);
850 
851  if (!trap->other_arch && !trap->inv) {
852  /* set the damage of the trap.
853  * we get 0-4 pts of damage per level of difficulty of the map in
854  * the trap
855  */
856 
857  trap->stats.dam = 0;
858  for (i = 0; i < difficulty; i++)
859  trap->stats.dam += rndm(0, 4);
860 
861  /* the poison trap special case */
862  if (trap->attacktype&AT_POISON) {
863  trap->stats.dam = rndm(0, difficulty-1);
864  if (trap->stats.dam < 1)
865  trap->stats.dam = 1;
866  }
867 
868  /* so we get an appropriate amnt of exp for AT_DEATH traps */
869  if (trap->attacktype&AT_DEATH)
870  trap->stats.dam = 127;
871  }
872 }
873 
874 #define DICE2 (get_magic(2) == 2 ? 2 : 1)
875 #define DICESPELL (RANDOM()%3+RANDOM()%3+RANDOM()%3+RANDOM()%3+RANDOM()%3)
876 
903 void fix_generated_item(object *op, object *creator, int difficulty, int max_magic, int flags) {
904  int was_magic = op->magic, num_enchantments = 0, save_item_power;
905 
906  if (!creator || creator->type == op->type)
907  creator = op; /* safety & to prevent polymorphed objects giving attributes */
908 
909  /* If we make an artifact, this information will be destroyed */
910  save_item_power = op->item_power;
911  op->item_power = 0;
912 
913  if (op->randomitems && op->type != SPELL) {
914  create_treasure(op->randomitems, op, flags, difficulty, 0);
915  if (!op->inv)
916  LOG(llevDebug, "fix_generated_item: Unable to generate treasure for %s\n", op->name);
917  /* So the treasure doesn't get created again */
918  op->randomitems = NULL;
919  }
920 
921  if (difficulty < 1)
922  difficulty = 1;
923  if (!(flags&GT_MINIMAL)) {
924  if (op->arch == crown_arch) {
925  set_magic(difficulty > 25 ? 30 : difficulty+5, op, max_magic, flags);
926  num_enchantments = calc_item_power(op);
927  generate_artifact(op, difficulty);
928  } else {
929  if (!op->magic && max_magic)
930  set_magic(difficulty, op, max_magic, flags);
931  num_enchantments = calc_item_power(op);
932  if ((!was_magic && !(RANDOM()%CHANCE_FOR_ARTIFACT))
933  || op->type == ROD
934  || difficulty >= 999)
935  generate_artifact(op, difficulty);
936  }
937 
938  /* Object was made an artifact. Calculate its item_power rating.
939  * the item_power in the object is what the artifact adds.
940  */
941  if (op->title) {
942  /* if save_item_power is set, then most likely we started with an
943  * artifact and have added new abilities to it - this is rare, but
944  * but I have seen things like 'strange rings of fire'. So just
945  * figure out the power from the base power plus what this one adds.
946  * Note that since item_power is not quite linear, this actually
947  * ends up being somewhat of a bonus.
948  */
949  if (save_item_power)
950  op->item_power = save_item_power+get_power_from_ench(op->item_power);
951  else
952  op->item_power += get_power_from_ench(num_enchantments);
953  } else if (save_item_power) {
954  /* restore the item_power field to the object if we haven't changed
955  * it. we don't care about num_enchantments - that will basically
956  * just have calculated some value from the base attributes of the
957  * archetype.
958  */
959  op->item_power = save_item_power;
960  } else {
961  /* item_power was zero. This is suspicious, as it may be because it
962  * was never previously calculated. Let's compute a value and see if
963  * it is non-zero. If it indeed is, then assign it as the new
964  * item_power value.
965  * - gros, 21th of July 2006.
966  */
967  op->item_power = calc_item_power(op);
968  save_item_power = op->item_power; /* Just in case it would get used
969  * again below */
970  }
971  } else {
972  /* If flag is GT_MINIMAL, we want to restore item power */
973  op->item_power = save_item_power;
974  }
975 
976  /* materialtype modifications. Note we allow this on artifacts. */
978 
979  if (flags&GT_MINIMAL) {
980  if (op->type == POTION)
981  /* Handle healing and magic power potions */
982  if (op->stats.sp && !op->randomitems) {
983  object *tmp;
984  if (spell_mapping[op->stats.sp]) {
985  tmp = create_archetype(spell_mapping[op->stats.sp]);
987  }
988  op->stats.sp = 0;
989  }
990  } else if (!op->title) { /* Only modify object if not special */
991  switch (op->type) {
992  case WEAPON:
993  case ARMOUR:
994  case SHIELD:
995  case HELMET:
996  case CLOAK:
997  if (QUERY_FLAG(op, FLAG_CURSED) && !(RANDOM()%4))
999  break;
1000 
1001  case BRACERS:
1002  if (!(RANDOM()%(QUERY_FLAG(op, FLAG_CURSED) ? 5 : 20))) {
1004  if (!QUERY_FLAG(op, FLAG_CURSED))
1005  op->value *= 3;
1006  }
1007  break;
1008 
1009  case POTION: {
1010  int too_many_tries = 0, is_special = 0;
1011 
1012  /* Handle healing and magic power potions */
1013  if (op->stats.sp && !op->randomitems) {
1014  object *tmp;
1015 
1016  tmp = create_archetype(spell_mapping[op->stats.sp]);
1018  op->stats.sp = 0;
1019  }
1020 
1021  while (!(is_special = special_potion(op)) && !op->inv) {
1022  generate_artifact(op, difficulty);
1023  if (too_many_tries++ > 10)
1024  break;
1025  }
1026  /* don't want to change value for healing/magic power potions,
1027  * since the value set on those is already correct.
1028  */
1029  if (op->inv && op->randomitems) {
1030  /* value multiplier is same as for scrolls */
1031  op->value = (op->value*op->inv->value);
1032  op->level = op->inv->level/2+RANDOM()%difficulty+RANDOM()%difficulty;
1033  } else {
1034  FREE_AND_COPY(op->name, "potion");
1035  FREE_AND_COPY(op->name_pl, "potions");
1036  }
1037  if (!(flags&GT_ONLY_GOOD) && RANDOM()%2)
1039  break;
1040  }
1041 
1042  case AMULET:
1043  if (op->arch == amulet_arch)
1044  op->value *= 5; /* Since it's not just decoration */
1045  /* fall through */
1046  case RING:
1047  if (op->arch == NULL) {
1048  object_remove(op);
1050  op = NULL;
1051  break;
1052  }
1053  if (op->arch != ring_arch && op->arch != amulet_arch)
1054  /* It's a special artifact!*/
1055  break;
1056 
1057  if (GET_ANIM_ID(op))
1058  SET_ANIMATION(op, RANDOM()%((int)NUM_ANIMATIONS(op)));
1059  if (!(flags&GT_ONLY_GOOD) && !(RANDOM()%3))
1062  if (op->type != RING) /* Amulets have only one ability */
1063  break;
1064  if (!(RANDOM()%4)) {
1065  int d = (RANDOM()%2 || QUERY_FLAG(op, FLAG_CURSED)) ? -DICE2 : DICE2;
1066  if (d > 0)
1067  op->value *= 3;
1068  set_ring_bonus(op, d);
1069  if (!(RANDOM()%4)) {
1070  int d = (RANDOM()%3 || QUERY_FLAG(op, FLAG_CURSED)) ? -DICE2 : DICE2;
1071  if (d > 0)
1072  op->value *= 5;
1073  set_ring_bonus(op, d);
1074  }
1075  }
1076  break;
1077 
1078  case BOOK:
1079  /* Is it an empty book?, if yes lets make a special
1080  * msg for it, and tailor its properties based on the
1081  * creator and/or map level we found it on.
1082  */
1083  if (!op->msg && RANDOM()%10) {
1084  /* set the book level properly */
1085  if (creator->level == 0 || QUERY_FLAG(creator, FLAG_ALIVE)) {
1086  if (op->map && op->map->difficulty)
1087  op->level = RANDOM()%(op->map->difficulty)+RANDOM()%10+1;
1088  else
1089  op->level = RANDOM()%20+1;
1090  } else
1091  op->level = RANDOM()%creator->level;
1092 
1093  tailor_readable_ob(op, creator->stats.sp);
1094  /* books w/ info are worth more! */
1095  if (op->msg != NULL)
1096  op->value *= ((op->level > 10 ? op->level : (op->level+1)/2)*((strlen(op->msg)/250)+1));
1097  /* creator related stuff */
1098 
1099  if (creator->slaying && !op->slaying) /* for check_inv floors */
1100  op->slaying = add_string(creator->slaying);
1101 
1102  /* add exp so reading it gives xp (once)*/
1103  op->stats.exp = op->value > 10000 ? op->value/5 : op->value/10;
1104  }
1105  /* for library, chained books. Note that some monsters have
1106  * no_pick set - we don't want to set no pick in that case. */
1107  if (QUERY_FLAG(creator, FLAG_NO_PICK)
1108  && !QUERY_FLAG(creator, FLAG_MONSTER))
1110  break;
1111 
1112  case SPELLBOOK:
1113  op->value = op->value*op->inv->value;
1114  /* add exp so learning gives xp */
1115  op->level = op->inv->level;
1116  op->stats.exp = op->value;
1117  /* some more fun */
1118  if (!(flags&GT_ONLY_GOOD) && rndm(1, 100) <= 5) {
1119  if (rndm(1, 6) <= 1)
1121  else
1123  } else if (rndm(1, 100) <= 1) {
1125  }
1126  break;
1127 
1128  case WAND:
1129  /* nrof in the treasure list is number of charges,
1130  * not number of wands. So copy that into food (charges),
1131  * and reset nrof.
1132  */
1133  op->stats.food = op->inv->nrof;
1134  op->nrof = 1;
1135  /* If the spell changes by level, choose a random level
1136  * for it, and adjust price. If the spell doesn't
1137  * change by level, just set the wand to the level of
1138  * the spell, and value calculation is simpler.
1139  */
1140  if (op->inv->duration_modifier
1141  || op->inv->dam_modifier
1142  || op->inv->range_modifier) {
1143  op->level = level_for_item(op, difficulty);
1144  op->value = op->value*op->inv->value*(op->level+50)/(op->inv->level+50);
1145  } else {
1146  op->level = op->inv->level;
1147  op->value = op->value*op->inv->value;
1148  }
1149  break;
1150 
1151  case ROD:
1152  op->level = level_for_item(op, difficulty);
1153  rod_adjust(op);
1154  break;
1155 
1156  case SCROLL:
1157  op->level = level_for_item(op, difficulty);
1158  op->value = op->value*op->inv->value*(op->level+50)/(op->inv->level+50);
1159  /* add exp so reading them properly gives xp */
1160  op->stats.exp = op->value/5;
1161  op->nrof = op->inv->nrof;
1162  /* some more fun */
1163  if (!(flags&GT_ONLY_GOOD) && rndm(1, 100) <= 20) {
1164  if (rndm(1, 6) <= 1)
1166  else
1168  } else if (rndm(1, 100) <= 2) {
1170  }
1171  break;
1172 
1173  case RUNE:
1174  trap_adjust(op, difficulty);
1175  break;
1176 
1177  case TRAP:
1178  trap_adjust(op, difficulty);
1179  break;
1180  } /* switch type */
1181  }
1182  if (flags&GT_STARTEQUIP) {
1183  if (op->nrof < 2
1184  && op->type != CONTAINER
1185  && op->type != MONEY
1188  else if (op->type != MONEY)
1189  op->value = 0;
1190  }
1191 
1192  if (!(flags&GT_ENVIRONMENT))
1193  fix_flesh_item(op, creator);
1194 }
1195 
1199 static void dump_monster_treasure_rec(const char *name, treasure *t, int depth) {
1200  treasurelist *tl;
1201  int i;
1202 
1203  if (depth > 100)
1204  return;
1205 
1206  while (t != NULL) {
1207  if (t->name != NULL) {
1208  for (i = 0; i < depth; i++)
1209  fprintf(logfile, " ");
1210  fprintf(logfile, "{ (list: %s)\n", t->name);
1211  tl = find_treasurelist(t->name);
1212  dump_monster_treasure_rec(name, tl->items, depth+2);
1213  for (i = 0; i < depth; i++)
1214  fprintf(logfile, " ");
1215  fprintf(logfile, "} (end of list: %s)\n", t->name);
1216  } else {
1217  for (i = 0; i < depth; i++)
1218  fprintf(logfile, " ");
1219  if (t->item->clone.type == FLESH)
1220  fprintf(logfile, "%s's %s\n", name, t->item->clone.name);
1221  else
1222  fprintf(logfile, "%s\n", t->item->clone.name);
1223  }
1224  if (t->next_yes != NULL) {
1225  for (i = 0; i < depth; i++)
1226  fprintf(logfile, " ");
1227  fprintf(logfile, " (if yes)\n");
1228  dump_monster_treasure_rec(name, t->next_yes, depth+1);
1229  }
1230  if (t->next_no != NULL) {
1231  for (i = 0; i < depth; i++)
1232  fprintf(logfile, " ");
1233  fprintf(logfile, " (if no)\n");
1234  dump_monster_treasure_rec(name, t->next_no, depth+1);
1235  }
1236  t = t->next;
1237  }
1238 }
1239 
1244 void dump_monster_treasure(const char *name) {
1245  int found;
1246 
1247  found = 0;
1248  fprintf(logfile, "\n");
1249  getManager()->archetypes()->each([&] (const auto at) {
1250  if (!strcasecmp(at->clone.name, name) && at->clone.title == NULL) {
1251  fprintf(logfile, "treasures for %s (arch: %s)\n", at->clone.name, at->name);
1252  if (at->clone.randomitems != NULL)
1253  dump_monster_treasure_rec(at->clone.name, at->clone.randomitems->items, 1);
1254  else
1255  fprintf(logfile, "(nothing)\n");
1256  fprintf(logfile, "\n");
1257  found++;
1258  }
1259  });
1260 
1261  if (found == 0)
1262  fprintf(logfile, "No objects have the name %s!\n\n", name);
1263 }
1264 
1272 static void fix_flesh_item(object *item, const object *donor) {
1273  char tmpbuf[MAX_BUF];
1274  int i;
1275 
1276  if (item->type == FLESH && donor && QUERY_FLAG(donor, FLAG_MONSTER)) {
1277  /* change the name */
1278  snprintf(tmpbuf, sizeof(tmpbuf), "%s's %s", donor->name, item->name);
1279  FREE_AND_COPY(item->name, tmpbuf);
1280  snprintf(tmpbuf, sizeof(tmpbuf), "%s's %s", donor->name, item->name_pl);
1281  FREE_AND_COPY(item->name_pl, tmpbuf);
1282 
1283  /* store original arch in other_arch */
1284  if (!item->other_arch) {
1285  if (!donor->arch->reference_count) {
1286  item->other_arch = donor->arch;
1287  } else {
1288  /* If dealing with custom monsters, other_arch still needs to
1289  * point back to the original. Otherwise what happens
1290  * is that other_arch points at the custom archetype, but
1291  * that can be freed. Reference count doesn't work because
1292  * the loader will not be able to resolve the other_arch at
1293  * load time (server may has restarted, etc.)
1294  */
1295  archetype *original = find_archetype(donor->arch->name);
1296 
1297  if (original)
1298  item->other_arch = original;
1299  else {
1300  LOG(llevError, "could not find original archetype %s for custom monster!\n", donor->arch->name);
1301  abort();
1302  }
1303  }
1304  }
1305 
1306  /* weight is FLESH weight/100 * donor */
1307  if ((item->weight = (signed long)(((double)item->weight/(double)100.0)*(double)donor->weight)) == 0)
1308  item->weight = 1;
1309 
1310  /* value is multiplied by level of donor */
1311  item->value *= isqrt(donor->level*2);
1312 
1313  /* food value */
1314  item->stats.food += (donor->stats.hp/100)+donor->stats.Con;
1315 
1316  /* flesh items inherit some abilities of donor, but not full effect. */
1317  for (i = 0; i < NROFATTACKS; i++)
1318  item->resist[i] = donor->resist[i]/2;
1319 
1320  /* item inherits donor's level and exp (important for dragons) */
1321  item->level = donor->level;
1322  item->stats.exp = donor->stats.exp;
1323 
1324  /* if donor has some attacktypes, the flesh is poisonous */
1325  if (donor->attacktype&AT_POISON)
1326  item->type = POISON;
1327  if (donor->attacktype&AT_ACID)
1328  item->stats.hp = -1*item->stats.food;
1330 
1331  /* attempt to change the face - will take a face named "donor's arch"_"item's face". We ignore the animation for now */
1332  if (item->face != NULL) {
1333  snprintf(tmpbuf, sizeof(tmpbuf), "%s_%s", donor->arch->name, item->face->name);
1334  item->face = try_find_face(tmpbuf, item->face);
1335  }
1336  }
1337 }
1338 
1347 static int special_potion(object *op) {
1348  int i;
1349 
1350  if (op->attacktype)
1351  return 1;
1352 
1353  if (op->stats.Str
1354  || op->stats.Dex
1355  || op->stats.Con
1356  || op->stats.Pow
1357  || op->stats.Wis
1358  || op->stats.Int
1359  || op->stats.Cha)
1360  return 1;
1361 
1362  for (i = 0; i < NROFATTACKS; i++)
1363  if (op->resist[i])
1364  return 1;
1365 
1366  return 0;
1367 }
1368 
1381  treasure *t = (treasure *)calloc(1, sizeof(treasure));
1382  if (t == NULL)
1384  t->item = NULL;
1385  t->name = NULL;
1386  t->next = NULL;
1387  t->next_yes = NULL;
1388  t->next_no = NULL;
1389  t->chance = 100;
1390  t->magic = 0;
1391  t->nrof = 0;
1392  return t;
1393 }
1394 
1402  if (t->name)
1403  free_string(t->name);
1404  if (t->artifact)
1405  free_string(t->artifact);
1406  if (t->next)
1407  treasure_free(t->next);
1408  if (t->next_yes)
1409  treasure_free(t->next_yes);
1410  if (t->next_no)
1411  treasure_free(t->next_no);
1412  free(t);
1413 }
1414 
1415 
1423  treasure *added = get_empty_treasure();
1424  if (list->items == NULL || position <= 0) {
1425  added->next = list->items;
1426  list->items = added;
1427  return added;
1428  }
1429  treasure *prev = list->items;
1430  position--;
1431  while (position > 0 && prev->next) {
1432  position--;
1433  prev = prev->next;
1434  }
1435  added->next = prev->next;
1436  prev->next = added;
1437  return added;
1438 }
1439 
1446  if (list->items == 0 || position < 0) {
1447  return;
1448  }
1449  if (position == 0) {
1450  treasure *next = list->items->next;
1451  list->items->next = NULL;
1452  treasure_free(list->items);
1453  list->items = next;
1454  return;
1455  }
1456  position--;
1457  treasure *prev = list->items;
1458  while (prev && position > 0) {
1459  position--;
1460  prev = prev->next;
1461  }
1462  if (!prev) {
1463  return;
1464  }
1465  treasure *next = prev->next->next;
1466  prev->next->next = NULL;
1467  treasure_free(prev->next);
1468  prev->next = next;
1469 }
give.next
def next
Definition: give.py:44
living::exp
int64_t exp
Definition: living.h:47
ATNR_PARALYZE
#define ATNR_PARALYZE
Definition: attack.h:61
set_magic
static void set_magic(int difficulty, object *op, int max_magic, int flags)
Definition: treasure.cpp:660
global.h
FREE_OBJ_NO_DESTROY_CALLBACK
#define FREE_OBJ_NO_DESTROY_CALLBACK
Definition: object.h:534
settings
struct Settings settings
Definition: init.cpp:138
set_abs_magic
void set_abs_magic(object *op, int magic)
Definition: treasure.cpp:612
dump_monster_treasure_rec
static void dump_monster_treasure_rec(const char *name, treasure *t, int depth)
Definition: treasure.cpp:1199
INS_NO_WALK_ON
#define INS_NO_WALK_ON
Definition: object.h:571
AT_POISON
#define AT_POISON
Definition: attack.h:86
BRACERS
@ BRACERS
Definition: object.h:220
find_artifact
const artifact * find_artifact(const object *op, const char *name)
Definition: artifact.cpp:589
llevError
@ llevError
Definition: logger.h:11
DICE2
#define DICE2
Definition: treasure.cpp:874
FABS
#define FABS(x)
Definition: define.h:22
WAND
@ WAND
Definition: object.h:223
LOG
void LOG(LogLevel logLevel, const char *format,...)
Definition: logger.cpp:51
SET_FLAG
#define SET_FLAG(xyz, p)
Definition: define.h:224
Settings::armor_speed_linear
uint8_t armor_speed_linear
Definition: global.h:309
FLESH
@ FLESH
Definition: object.h:190
object::inv
object * inv
Definition: object.h:296
ATNR_ACID
#define ATNR_ACID
Definition: attack.h:55
FLAG_STARTEQUIP
#define FLAG_STARTEQUIP
Definition: define.h:268
num_resist_table
#define num_resist_table
Definition: treasure.cpp:53
QUERY_FLAG
#define QUERY_FLAG(xyz, p)
Definition: define.h:226
FLAG_REFL_MISSILE
#define FLAG_REFL_MISSILE
Definition: define.h:273
treasurelist::items
treasure * items
Definition: treasure.h:92
AssetsManager.h
level_for_item
static int level_for_item(const object *op, int difficulty)
Definition: treasure.cpp:323
object::arch
struct archetype * arch
Definition: object.h:420
treasurelist::total_chance
int16_t total_chance
Definition: treasure.h:87
FLAG_OBJ_ORIGINAL
#define FLAG_OBJ_ORIGINAL
Definition: define.h:357
TRAP
@ TRAP
Definition: object.h:244
object::x
int16_t x
Definition: object.h:333
ARMOUR
@ ARMOUR
Definition: object.h:123
guildoracle.list
list
Definition: guildoracle.py:87
give_artifact_abilities
void give_artifact_abilities(object *op, const object *artifact)
Definition: artifact.cpp:230
object::map
struct mapstruct * map
Definition: object.h:303
WEAPON
@ WEAPON
Definition: object.h:122
guildjoin.ob
ob
Definition: guildjoin.py:42
GT_ONLY_GOOD
@ GT_ONLY_GOOD
Definition: treasure.h:34
artifact::item
object * item
Definition: artifact.h:15
SET_ANIMATION
#define SET_ANIMATION(ob, newanim)
Definition: global.h:162
ATNR_SLOW
#define ATNR_SLOW
Definition: attack.h:60
AMULET
@ AMULET
Definition: object.h:142
fix_generated_item
void fix_generated_item(object *op, object *creator, int difficulty, int max_magic, int flags)
Definition: treasure.cpp:903
get_power_from_ench
int get_power_from_ench(int ench)
Definition: item.cpp:211
flags
static const flag_definition flags[]
Definition: gridarta-types-convert.cpp:101
MAXMAGIC
#define MAXMAGIC
Definition: treasure.h:13
RUNE
@ RUNE
Definition: object.h:243
set_materialname
void set_materialname(object *op)
Definition: utils.cpp:297
MAX_SPELLITEM_LEVEL
#define MAX_SPELLITEM_LEVEL
Definition: treasure.h:19
ATNR_DISEASE
#define ATNR_DISEASE
Definition: attack.h:74
find_treasurelist
treasurelist * find_treasurelist(const char *name)
Definition: assets.cpp:249
Ice.tmp
int tmp
Definition: Ice.py:207
FLAG_BLESSED
#define FLAG_BLESSED
Definition: define.h:369
rod_adjust
void rod_adjust(object *rod)
Definition: main.cpp:390
ATNR_PHYSICAL
#define ATNR_PHYSICAL
Definition: attack.h:49
ARMOUR_SPEED
#define ARMOUR_SPEED(xyz)
Definition: define.h:466
special_potion
static int special_potion(object *op)
Definition: treasure.cpp:1347
NROFATTACKS
#define NROFATTACKS
Definition: attack.h:17
create_all_treasures
static void create_all_treasures(treasure *t, object *op, int flag, int difficulty, int tries)
Definition: treasure.cpp:175
rndm
int rndm(int min, int max)
Definition: utils.cpp:162
ATNR_TURN_UNDEAD
#define ATNR_TURN_UNDEAD
Definition: attack.h:62
create_treasure
void create_treasure(treasurelist *t, object *op, int flag, int difficulty, int tries)
Definition: treasure.cpp:263
object::level
int16_t level
Definition: object.h:359
get_magic
static int get_magic(int diff)
Definition: treasure.cpp:815
GT_STARTEQUIP
@ GT_STARTEQUIP
Definition: treasure.h:33
getManager
AssetsManager * getManager()
Definition: assets.cpp:305
object_insert_in_ob
object * object_insert_in_ob(object *op, object *where)
Definition: object.cpp:2851
AT_DEATH
#define AT_DEATH
Definition: attack.h:93
object::resist
int16_t resist[NROFATTACKS]
Definition: object.h:349
FLAG_NO_PICK
#define FLAG_NO_PICK
Definition: define.h:239
ATNR_CONFUSION
#define ATNR_CONFUSION
Definition: attack.h:54
ATNR_HOLYWORD
#define ATNR_HOLYWORD
Definition: attack.h:70
FLAG_ALIVE
#define FLAG_ALIVE
Definition: define.h:230
ATNR_BLIND
#define ATNR_BLIND
Definition: attack.h:71
object::y
int16_t y
Definition: object.h:333
CLOAK
@ CLOAK
Definition: object.h:207
object_free_drop_inventory
void object_free_drop_inventory(object *ob)
Definition: object.cpp:1560
HELMET
@ HELMET
Definition: object.h:139
POISON
@ POISON
Definition: object.h:116
magic_from_difficulty
static int magic_from_difficulty(int difficulty)
Definition: treasure.cpp:572
trap_adjust
static void trap_adjust(object *trap, int difficulty)
Definition: treasure.cpp:836
init_archetype_pointers
void init_archetype_pointers(void)
Definition: treasure.cpp:62
amulet_arch
static archetype * amulet_arch
Definition: treasure.cpp:50
POTION
@ POTION
Definition: object.h:114
GT_INVISIBLE
@ GT_INVISIBLE
Definition: treasure.h:32
do_single_item
static void do_single_item(treasure *t, object *op, int flag, int difficulty)
Definition: treasure.cpp:139
treasurelist
Definition: treasure.h:85
add_string
sstring add_string(const char *str)
Definition: shstr.cpp:124
ROD
@ ROD
Definition: object.h:112
CONTAINER
@ CONTAINER
Definition: object.h:234
set_attr_value
void set_attr_value(living *stats, int attr, int8_t value)
Definition: living.cpp:218
treasure_free
void treasure_free(treasure *t)
Definition: treasure.cpp:1401
tailor_readable_ob
void tailor_readable_ob(object *book, int msg_type)
Definition: readable.cpp:1869
change_treasure
static void change_treasure(treasure *t, object *op)
Definition: treasure.cpp:105
Settings::armor_weight_reduction
int armor_weight_reduction
Definition: global.h:306
isqrt
int isqrt(int n)
Definition: utils.cpp:559
FREE_AND_COPY
#define FREE_AND_COPY(sv, nv)
Definition: global.h:204
Ice.b
b
Definition: Ice.py:48
object::type
uint8_t type
Definition: object.h:346
INS_NO_MERGE
#define INS_NO_MERGE
Definition: object.h:569
FLAG_DAMNED
#define FLAG_DAMNED
Definition: define.h:317
living::dam
int16_t dam
Definition: living.h:46
ATNR_DRAIN
#define ATNR_DRAIN
Definition: attack.h:56
object_free
void object_free(object *ob, int flags)
Definition: object.cpp:1592
archetype
Definition: object.h:472
ATNR_POISON
#define ATNR_POISON
Definition: attack.h:59
sproto.h
resist_table
static int resist_table[]
Definition: treasure.cpp:39
logfile
FILE * logfile
Definition: init.cpp:114
ATNR_DEATH
#define ATNR_DEATH
Definition: attack.h:66
living::sp
int16_t sp
Definition: living.h:42
AssetsCollection::each
void each(std::function< void(T *)> op)
Definition: AssetsCollection.h:158
FLAG_NO_STEAL
#define FLAG_NO_STEAL
Definition: define.h:342
GET_ANIM_ID
#define GET_ANIM_ID(ob)
Definition: global.h:165
BOOK
@ BOOK
Definition: object.h:117
GT_ENVIRONMENT
@ GT_ENVIRONMENT
Definition: treasure.h:31
RING
@ RING
Definition: object.h:188
set_ring_bonus
static void set_ring_bonus(object *op, int bonus)
Definition: treasure.cpp:689
object_insert_in_map_at
object * object_insert_in_map_at(object *op, mapstruct *m, object *originator, int flag, int x, int y)
Definition: object.cpp:2098
object::other_arch
struct archetype * other_arch
Definition: object.h:421
treasure::next
treasure * next
Definition: treasure.h:69
FLAG_MONSTER
#define FLAG_MONSTER
Definition: define.h:245
fatal
void fatal(enum fatal_error err)
Definition: utils.cpp:570
AssetsManager::archetypes
Archetypes * archetypes()
Definition: AssetsManager.h:44
treasure.h
MAX_BUF
#define MAX_BUF
Definition: define.h:35
object_new
object * object_new(void)
Definition: object.cpp:1273
treasure_remove_item
void treasure_remove_item(treasurelist *list, int position)
Definition: treasure.cpp:1445
create_archetype
object * create_archetype(const char *name)
Definition: arch.cpp:278
object::weight
int32_t weight
Definition: object.h:373
free_string
void free_string(sstring str)
Definition: shstr.cpp:280
RANDOM
#define RANDOM()
Definition: define.h:644
difftomagic_list
static const int difftomagic_list[DIFFLEVELS][MAXMAGIC+1]
Definition: treasure.cpp:359
ATNR_FIRE
#define ATNR_FIRE
Definition: attack.h:51
is_valid_types_gen.found
found
Definition: is_valid_types_gen.py:39
put_treasure
static void put_treasure(object *op, object *creator, int flags)
Definition: treasure.cpp:82
FLAG_REFL_SPELL
#define FLAG_REFL_SPELL
Definition: define.h:275
Floor.t
t
Definition: Floor.py:62
object::slaying
sstring slaying
Definition: object.h:325
object::name
sstring name
Definition: object.h:317
get_empty_treasure
treasure * get_empty_treasure(void)
Definition: treasure.cpp:1380
ATNR_DEPLETE
#define ATNR_DEPLETE
Definition: attack.h:65
item
Definition: item.py:1
living::Cha
int8_t Cha
Definition: living.h:36
give.op
op
Definition: give.py:33
autojail.value
value
Definition: autojail.py:6
find_archetype
archetype * find_archetype(const char *name)
Definition: assets.cpp:266
spell_mapping
const char *const spell_mapping[SPELL_MAPPINGS]
Definition: object.cpp:74
archetype::reference_count
int reference_count
Definition: object.h:479
ATNR_MAGIC
#define ATNR_MAGIC
Definition: attack.h:50
assets.h
CHANCE_FOR_ARTIFACT
#define CHANCE_FOR_ARTIFACT
Definition: treasure.h:10
fix_flesh_item
static void fix_flesh_item(object *item, const object *donor)
Definition: treasure.cpp:1272
NUM_ANIMATIONS
#define NUM_ANIMATIONS(ob)
Definition: global.h:171
treasure_insert
treasure * treasure_insert(treasurelist *list, int position)
Definition: treasure.cpp:1422
dump_monster_treasure
void dump_monster_treasure(const char *name)
Definition: treasure.cpp:1244
arch_to_object
object * arch_to_object(archetype *at)
Definition: arch.cpp:229
level
int level
Definition: readable.cpp:1549
DIFFLEVELS
#define DIFFLEVELS
Definition: treasure.h:16
Settings::armor_weight_linear
uint8_t armor_weight_linear
Definition: global.h:307
strcasecmp
int strcasecmp(const char *s1, const char *s2)
make_face_from_files.int
int
Definition: make_face_from_files.py:26
AT_ACID
#define AT_ACID
Definition: attack.h:82
loader.h
object_remove
void object_remove(object *op)
Definition: object.cpp:1833
try_find_face
const Face * try_find_face(const char *name, const Face *error)
Definition: assets.cpp:286
crown_arch
static archetype * crown_arch
Definition: treasure.cpp:50
generate_treasure
object * generate_treasure(treasurelist *t, int difficulty)
Definition: treasure.cpp:295
FREE_OBJ_FREE_INVENTORY
#define FREE_OBJ_FREE_INVENTORY
Definition: object.h:533
ATNR_GHOSTHIT
#define ATNR_GHOSTHIT
Definition: attack.h:58
ATNR_COLD
#define ATNR_COLD
Definition: attack.h:53
archetype::name
sstring name
Definition: object.h:473
SCROLL
@ SCROLL
Definition: object.h:224
create_one_treasure
static void create_one_treasure(treasurelist *tl, object *op, int flag, int difficulty, int tries)
Definition: treasure.cpp:210
object::stats
living stats
Definition: object.h:376
treasure
Definition: treasure.h:63
artifact
Definition: artifact.h:14
get_attr_value
int8_t get_attr_value(const living *stats, int attr)
Definition: living.cpp:313
calc_item_power
int calc_item_power(const object *op)
Definition: item.cpp:239
ATNR_ELECTRICITY
#define ATNR_ELECTRICITY
Definition: attack.h:52
SPELL
@ SPELL
Definition: object.h:217
ring_arch
static archetype * ring_arch
Definition: treasure.cpp:50
SHIELD
@ SHIELD
Definition: object.h:138
object::attacktype
uint32_t attacktype
Definition: object.h:350
OUT_OF_MEMORY
@ OUT_OF_MEMORY
Definition: define.h:48
FLAG_CURSED
#define FLAG_CURSED
Definition: define.h:316
ATNR_LIFE_STEALING
#define ATNR_LIFE_STEALING
Definition: attack.h:73
generate_artifact
void generate_artifact(object *op, int difficulty)
Definition: artifact.cpp:177
FLAG_IS_THROWN
#define FLAG_IS_THROWN
Definition: define.h:249
if
if(!(yy_init))
Definition: loader.c:2626
Settings::armor_speed_improvement
int armor_speed_improvement
Definition: global.h:308
SPELLBOOK
@ SPELLBOOK
Definition: object.h:206
GT_MINIMAL
@ GT_MINIMAL
Definition: treasure.h:36
living::hp
int16_t hp
Definition: living.h:40
ring_occidental_mages.r
r
Definition: ring_occidental_mages.py:6
llevDebug
@ llevDebug
Definition: logger.h:13
MONEY
@ MONEY
Definition: object.h:140
living::Con
int8_t Con
Definition: living.h:36
give.name
name
Definition: give.py:27
legal_artifact_combination
int legal_artifact_combination(const object *op, const artifact *art)
Definition: artifact.cpp:252
ATNR_FEAR
#define ATNR_FEAR
Definition: attack.h:63
level
Definition: level.py:1