Crossfire Server, Trunk
c_object.c
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  */
19 #include "global.h"
20 
21 #include <ctype.h>
22 #include <math.h>
23 #include <stdlib.h>
24 #include <string.h>
25 
26 #include "living.h"
27 #include "loader.h"
28 #include "shop.h"
29 #include "skills.h"
30 #include "sproto.h"
31 
33 static const char *pickup_names[] = {
34  "debug", "inhibit", "stop", "food", "drink",
35  "valuables", "bow", "arrow", "helmet", "shield",
36  "armour", "boots", "gloves", "cloak", "key",
37  "missile", "melee", "magical", "potion", "spellbook",
38  "skillscroll", "readables", "magicdevice", "notcursed", "jewels",
39  "flesh", "container", "cursed", NULL
40 };
41 
43 static const uint32_t pickup_modes[] = {
48 };
49 
58 static int get_pickup_mode_index(const char *name) {
59  int best = -1;
60  size_t len = strlen(name);
61  for (size_t mode = 0; pickup_names[mode]; mode++) {
62  if (!strcmp(pickup_names[mode], name)) {
63  return mode;
64  }
65  if (len < strlen(pickup_names[mode]) && strncmp(name, pickup_names[mode], len) == 0) {
66  if (best != -2) {
67  if (best != -1) {
68  best = -2;
69  } else {
70  best = mode;
71  }
72  }
73  }
74  }
75  return best != -2 ? best : -1;
76 }
77 
78 static void set_pickup_mode(const object *op, int i);
79 
80 /*
81  * Object id parsing functions
82  */
83 
101 static object *find_best_apply_object_match(object *start, object *pl, const char *params, int aflag) {
102  object *tmp, *best = NULL;
103  int match_val = 0, tmpmatch;
104 
105  tmp = start;
107  if (tmp->invisible)
108  continue;
109  if (aflag == AP_APPLY && QUERY_FLAG(tmp, FLAG_APPLIED))
110  continue;
111  if (aflag == AP_UNAPPLY && !QUERY_FLAG(tmp, FLAG_APPLIED))
112  continue;
113  tmpmatch = object_matches_string(pl, tmp, params);
114  if (tmpmatch > match_val) {
115  match_val = tmpmatch;
116  best = tmp;
117  }
119  return best;
120 }
121 
132 static object *find_best_object_match(object *pl, const char *params) {
134 }
135 
144 void command_uskill(object *pl, const char *params) {
145  if (*params == '\0') {
147  "Usage: use_skill <skill name>");
148  return;
149  }
150  use_skill(pl, params);
151 }
152 
161 void command_rskill(object *pl, const char *params) {
162  object *skill;
163 
164  if (*params == '\0') {
166  "Usage: ready_skill <skill name>");
167  return;
168  }
169  skill = find_skill_by_name(pl, params);
170 
171  if (!skill) {
173  "You have no knowledge of the skill %s",
174  params);
175  return;
176  }
177  change_skill(pl, skill, 0);
178 }
179 
188 static void do_skill_by_number(object *op, int skill_subtype, const char *params,
189  const char *missing_message) {
190  object *skop = find_skill_by_number(op, skill_subtype);
191  if (skop) {
192  do_skill(op, op, skop, op->facing, *params == '\0' ? NULL : params);
193  return;
194  }
195 
197  missing_message);
198 }
199 
200 /* These functions (command_search, command_disarm) are really juse wrappers for
201  * things like 'use_skill ...'). In fact, they should really be obsoleted
202  * and replaced with those.
203  */
212 void command_search(object *op, const char *params) {
213  do_skill_by_number(op, SK_FIND_TRAPS, params, "You don't know how to search for unusual things.");
214 }
215 
224 void command_disarm(object *op, const char *params) {
225  do_skill_by_number(op, SK_DISARM_TRAPS, params, "You don't know how to disarm traps.");
226 }
227 
239 void command_throw(object *op, const char *params) {
240  do_skill_by_number(op, SK_THROWING, params, "You have no knowledge of the skill throwing.");
241 }
242 
251 void command_apply(object *op, const char *params) {
252  int aflag = 0;
253  object *inv = op->inv;
254  object *item;
255 
256  if (*params == '\0') {
258  return;
259  }
260 
261  while (*params == ' ')
262  params++;
263  if (!strncmp(params, "-a ", 3)) {
264  aflag = AP_APPLY;
265  params += 3;
266  }
267  if (!strncmp(params, "-u ", 3)) {
268  aflag = AP_UNAPPLY;
269  params += 3;
270  }
271  if (!strncmp(params, "-o ", 3)) {
272  aflag = AP_OPEN;
273  params += 3;
274  }
275  if (!strncmp(params, "-b ", 3)) {
276  params += 3;
277  if (op->container)
278  inv = op->container->inv;
279  else {
280  inv = op;
281  while (inv->above)
282  inv = inv->above;
283  }
284  }
285  while (*params == ' ')
286  params++;
287 
289  if (item == NULL)
291  if (item) {
292  apply_by_living(op, item, aflag, 0);
293  } else
295  "Could not find any match to the %s.",
296  params);
297 }
298 
317 int sack_can_hold(const object *pl, const object *sack, const object *op, uint32_t nrof) {
318  char name[MAX_BUF];
319  query_name(sack, name, MAX_BUF);
320 
321  if (!QUERY_FLAG(sack, FLAG_APPLIED)) {
323  "The %s is not active.",
324  name);
325  return 0;
326  }
327  if (sack == op) {
329  "You can't put the %s into itself.",
330  name);
331  return 0;
332  }
333  if (sack->race
334  && (sack->race != op->race || op->type == CONTAINER || (sack->stats.food && sack->stats.food != op->type))) {
336  "You can put only %s into the %s.",
337  sack->race, name);
338  return 0;
339  }
340  if (op->type == SPECIAL_KEY && sack->slaying && op->slaying) {
342  "You can't put the key into %s.",
343  name);
344  return 0;
345  }
346  if (sack->weight_limit) {
347  int32_t new_weight;
348 
349  new_weight = sack->carrying+(nrof ? nrof : 1)
350  /* Most non-containers should have op->carrying == 0. Icecubes, however, will not,
351  * and we need to handle those.
352  * Daniel Hawkins 2021-01-21
353  */
354  *(op->weight+(op->type == CONTAINER ? op->carrying*op->stats.Str : op->carrying))
355  *(100-sack->stats.Str)/100;
356  if (new_weight > sack->weight_limit) {
358  "That won't fit in the %s!",
359  name);
360  return 0;
361  }
362  }
363  /* All other checks pass, must be OK */
364  return 1;
365 }
366 
379 static void pick_up_object(object *pl, object *op, object *tmp, int nrof) {
380  /* buf needs to be big (more than 256 chars) because you can get
381  * very long item names.
382  */
383  char buf[HUGE_BUF], name[MAX_BUF];
384  object *env = tmp->env;
385  uint32_t weight, effective_weight_limit;
386  const int tmp_nrof = NROF(tmp);
387  tag_t tag;
388  mapstruct* map = tmp->map;
389  int16_t x = tmp->x, y = tmp->y;
390 
391  /* IF the player is flying & trying to take the item out of a container
392  * that is in his inventory, let him. tmp->env points to the container
393  * (sack, luggage, etc), tmp->env->env then points to the player (nested
394  * containers not allowed as of now)
395  */
396  if ((pl->move_type&MOVE_FLYING)
397  && !QUERY_FLAG(pl, FLAG_WIZ)
400  "You are levitating, you can't reach the ground!");
401  return;
402  }
404  return;
405 
408  "The object disappears in a puff of smoke! It must have been an illusion.");
409  if (!QUERY_FLAG(tmp, FLAG_REMOVED))
412  return;
413  }
414 
415  if (nrof > tmp_nrof || nrof == 0)
416  nrof = tmp_nrof;
417 
418  /* Figure out how much weight this object will add to the player */
419  weight = tmp->weight*nrof;
420  if (tmp->inv)
421  weight += tmp->carrying*(100-tmp->stats.Str)/100;
422 
423  effective_weight_limit = get_weight_limit(MIN(pl->stats.Str, settings.max_stat));
424 
425  if (pl->weight+pl->carrying+weight > effective_weight_limit) {
427  "That item is too heavy for you to pick up.");
428  return;
429  }
430 
433 
434  if (nrof != tmp_nrof) {
435  char failure[MAX_BUF];
436 
437  tmp = object_split(tmp, nrof, failure, sizeof(failure));
438  if (!tmp) {
440  failure);
441  return;
442  }
443  } else {
444  /* If the object is in a container, send a delete to the client.
445  * - we are moving all the items from the container to elsewhere,
446  * so it needs to be deleted.
447  */
448  if (!QUERY_FLAG(tmp, FLAG_REMOVED)) {
449  object_remove(tmp); /* Unlink it */
450  }
451  }
453 
454  if (QUERY_FLAG(tmp, FLAG_UNPAID)) {
455  char *value = cost_str(shop_price_buy(tmp, pl));
456  if (op == pl) {
457  snprintf(buf, sizeof(buf), "%s will cost you %s.", name, value);
458  } else {
459  snprintf(buf, sizeof(buf), "%s will cost you %s. You place it in your %s.", name, value, op->name);
460  }
461  free(value);
462  } else {
463  if (op == pl) {
464  snprintf(buf, sizeof(buf), "You pick up the %s.", name);
465  } else {
466  snprintf(buf, sizeof(buf), "You pick up the %s and put it in your %s.", name, op->name);
467  }
468  }
469 
470  /* Now item is about to be picked. */
471  tag = tmp->count;
473  /* put item back, if it still exists */
474  if (tmp->count == tag && !QUERY_FLAG(tmp, FLAG_FREED)) {
475  if (env != NULL) {
477  } else {
478  object_insert_in_map_at(tmp, map, NULL, 0, x, y);
479  }
480  }
481  return;
482  }
483 
485  buf);
486 
488 
489  /* All the stuff below deals with client/server code, and is only
490  * usable by players
491  */
492  if (pl->type != PLAYER)
493  return;
494 
495  /* Additional weight changes speed, etc */
496  fix_object(pl);
497 
498  /* These are needed to update the weight for the container we
499  * are putting the object in.
500  */
501  if (op != pl) {
504  }
505 
506  /* Update the container the object was in */
507  if (env && env != pl && env != op)
509 }
510 
519 void pick_up(object *op, object *alt) {
520 /* modified slightly to allow monsters use this -b.t. 5-31-95 */
521  object *tmp = NULL, *tmp1;
522  mapstruct *tmp_map = NULL;
523  int count;
524 
525  /* Decide which object to pick. */
526  if (alt) {
527  if (!object_can_pick(op, alt)) {
529  "You can't pick up the %s.",
530  alt->name);
531  return;
532  }
533  tmp = alt;
534  } else {
535  if (op->below == NULL || !object_can_pick(op, op->below)) {
537  "There is nothing to pick up here.");
538  return;
539  }
540  tmp = op->below;
541  }
542 
543  /* it is possible that the object is a thrown object and is flying about.
544  * in that case, what we want to pick up is the payload. Objects
545  * that are thrown are encapsulated into a thrown object.
546  * stop_item() returns the payload (unlinked from map) and gets rid of the
547  * container object. If this object isn't picked up, we need to insert
548  * it back on the map.
549  * A bug here is that even attempting to pick up one of these objects will
550  * result in this logic being called even if player is unable to pick it
551  * up.
552  */
553 
554  tmp_map = tmp->map;
555  tmp1 = stop_item(tmp);
556  if (tmp1 == NULL)
557  return;
558 
559  /* If it is a thrown object, insert it back into the map here.
560  * makes life easier further along. Do no merge so pick up code
561  * behaves more sanely.
562  */
563  if (tmp1 != tmp) {
564  tmp = object_insert_in_map(tmp1, tmp_map, op, INS_NO_MERGE);
565  }
566 
567  if (tmp == NULL)
568  return;
569 
570  if (!object_can_pick(op, tmp))
571  return;
572 
573  /* Establish how many of the object we are picking up */
574  if (op->type == PLAYER) {
575  count = op->contr->count;
576  if (count == 0)
577  count = tmp->nrof;
578  } else
579  count = tmp->nrof;
580 
581  /* container is open, so use it */
582  if (op->container) {
583  alt = op->container;
584  if (alt != tmp->env && !sack_can_hold(op, alt, tmp, count))
585  return;
586  } else {
587  /* non container pickup. See if player has any
588  * active containers.
589  */
590  object *container = NULL;
591 
592  /* Look for any active containers that can hold this item.
593  * we cover two cases here - the perfect match case, where we
594  * break out of the loop, and the general case (have a container),
595  * Moved this into a single loop - reduces redundant code, is
596  * more efficient and easier to follow. MSW 2009-04-06
597  */
598  alt = op->inv;
600  if (alt->type == CONTAINER
601  && QUERY_FLAG(alt, FLAG_APPLIED)
602  && sack_can_hold(NULL, alt, tmp, count)) {
603  if (alt->race && alt->race == tmp->race) {
604  break; /* perfect match */
605  } else if (!container) {
606  container = alt;
607  }
608  }
610  /* Note container could be null, but no reason to check for it */
611  if (!alt)
612  alt = container;
613 
614  if (!alt)
615  alt = op; /* No free containers */
616  }
617  /* see if this object is already in this container. If so,
618  * move it to player inventory from this container.
619  */
620  if (tmp->env == alt) {
621  alt = op;
622  }
623 
624  /* Don't allow players to be put into containers. Instead,
625  * just put them in the players inventory.
626  */
627  if ((tmp->type == CONTAINER || tmp->type == MIMIC) && alt->type==CONTAINER) {
628  alt = op;
629  }
630 #ifdef PICKUP_DEBUG
631  LOG(llevDebug, "Pick_up(): %s picks %s (%d) and inserts it %s.\n", op->name, tmp->name, op->contr->count, alt->name);
632 #endif
633 
634  /* startequip items are not allowed to be put into containers
635  * Not sure why we have this limitation
636  */
637  if (op->type == PLAYER
638  && alt->type == CONTAINER
641  "This object cannot be put into containers!");
642  return;
643  }
644 
645  pick_up_object(op, alt, tmp, count);
646  if (op->type == PLAYER)
647  op->contr->count = 0;
648 }
649 
656 int object_matches_pickup_mode(const object *item, int mode) {
657  switch(mode) {
658  case PU_FOOD:
659  return item->type == FOOD;
660  case PU_DRINK:
661  return item->type == DRINK || (item->type == POISON && !QUERY_FLAG(item, FLAG_KNOWN_CURSED));
662  case PU_FLESH:
663  return item->type == FLESH;
664  case PU_POTION:
665  return item->type == POTION;
666  case PU_SPELLBOOK:
667  return item->type == SPELLBOOK;
668  case PU_SKILLSCROLL:
669  return item->type == SKILLSCROLL;
670  case PU_READABLES:
671  return item->type == BOOK || item->type == SCROLL;
672  case PU_MAGIC_DEVICE:
673  return item->type == WAND || item->type == ROD || item->type == WEAPON_IMPROVER || item->type == ARMOUR_IMPROVER || item->type == SKILL_TOOL;
674  case PU_MAGICAL:
676  case PU_VALUABLES:
677  return item->type == MONEY || item->type == GEM;
678  case PU_JEWELS:
679  return item->type == RING || item->type == AMULET;
680  case PU_BOW:
681  return item->type == BOW;
682  case PU_ARROW:
683  return item->type == ARROW;
684  case PU_ARMOUR:
685  return item->type == ARMOUR;
686  case PU_HELMET:
687  return item->type == HELMET;
688  case PU_SHIELD:
689  return item->type == SHIELD;
690  case PU_BOOTS:
691  return item->type == BOOTS;
692  case PU_GLOVES:
693  return item->type == GLOVES;
694  case PU_CLOAK:
695  return item->type == CLOAK;
696  case PU_MISSILEWEAPON:
697  return item->type == WEAPON && QUERY_FLAG(item, FLAG_IS_THROWN);
698  case PU_MELEEWEAPON:
699  return item->type == WEAPON;
700  case PU_KEY:
701  return item->type == KEY || item->type == SPECIAL_KEY;
702  case PU_CONTAINER:
703  return item->type == CONTAINER;
704  case PU_CURSED:
706  }
707  return 0;
708 }
709 
711 typedef struct {
712  union {
713  struct {
717  };
718  char name[100];
720  };
721  int missed;
723 
731 typedef int (*item_matcher)(object *who, matcher_params *params, object *item);
732 
740 static int matcher_all(object *who, matcher_params *params, object *item) {
741  (void)who;
742  (void)params;
743  (void)item;
744  return 1;
745 }
746 
754 static int matcher_number(object *who, matcher_params *params, object *item) {
755  if (params->item_must_be_pickable == 0 || object_can_pick(who, item)) {
756  params->item_number++;
757  }
758  if (params->item_to_pick == params->item_number) {
759  /* Since we don't always increase item_number, multiple items may have the same index,
760  including unpickable ones, so to avoid failure messages just ensure no other item can be picked. */
761  params->item_to_pick = 0;
762  return 1;
763  }
764  return 0;
765 }
766 
774 static int matcher_name(object *who, matcher_params *params, object *item) {
775  int ival = object_matches_string(who, item, params->name);
776  if (ival > 0) {
777  if (ival <= 2 && !object_can_pick(who, item)) {
778  if (!QUERY_FLAG(item, FLAG_IS_FLOOR))/* don't count floor tiles */
779  params->missed++;
780  return 0;
781  }
782  return 1;
783  }
784  return 0;
785 }
786 
794 static int matcher_pickup_type(object *who, matcher_params *params, object *item) {
795  (void)who;
796  return object_matches_pickup_mode(item, params->pickup_type);
797 }
798 
806 static item_matcher make_matcher(object *who, const char *params, matcher_params *mp) {
807  memset(mp, 0, sizeof(*mp));
808  if (params[0] == '\0') {
809  mp->item_to_pick = 1;
810  mp->item_must_be_pickable = 1;
811  return &matcher_number;
812  }
813  if (params[0] == '#') {
814  mp->item_to_pick = atoi(params + 1);
815  if (mp->item_to_pick == 0) {
817  return NULL;
818  }
819  return &matcher_number;
820  }
821  if (params[0] == '*') {
822  if (params[1] == '\0') {
823  return &matcher_all;
824  }
825  int idx = get_pickup_mode_index(params + 1);
826  if (idx == -1) {
828  return NULL;
829  }
830  mp->pickup_type = pickup_modes[idx];
831  return &matcher_pickup_type;
832  }
833  strncpy(mp->name, params, sizeof(mp->name) - 1);
834  return &matcher_name;
835 }
836 
845 void command_take(object *op, const char *params) {
846  object *tmp;
847  int did_one = 0;
848 
849  if (op->container)
850  tmp = op->container->inv;
851  else {
852  tmp = op->above;
853  if (tmp)
854  while (tmp->above) {
855  tmp = tmp->above;
856  }
857  if (!tmp)
858  tmp = op->below;
859  }
860 
861  if (tmp == NULL) {
863  "Nothing to take!");
864  return;
865  }
866 
867  matcher_params mp;
868  item_matcher matcher = make_matcher(op, params, &mp);
869  if (!matcher) {
870  return; // Player already informed of failure.
871  }
872 
874 
876  if (tmp->invisible) {
877  continue;
878  }
879  if ((*matcher)(op, &mp, tmp)) {
880  pick_up(op, tmp);
881  did_one = 1;
882  }
884 
885  /* Nothing picked up, check if unable to pick or nothing to pick. */
886  if (params[0] == '\0' && !did_one) {
887  int found = 0;
889  if (!tmp->invisible) {
891  "You can't pick up a %s.",
892  tmp->name ? tmp->name : "null");
893  found = 1;
894  break;
895  }
897  if (!found)
899  "There is nothing to pick up.");
900  }
901 
902  if (mp.missed == 1)
904  "You were unable to take one of the items.");
905  else if (mp.missed > 1)
907  "You were unable to take %d of the items.",
908  mp.missed);
909 
910  /* Now update player and send information. */
912  fix_object(op);
913  if (op->type == PLAYER) {
914  op->contr->count = 0;
916  }
917 }
918 
937 void put_object_in_sack(object *op, object *sack, object *tmp, uint32_t nrof) {
938  object *sack2, *orig = sack;
939  char name_sack[MAX_BUF], name_tmp[MAX_BUF];
940 
941  if (sack == tmp)
942  return; /* Can't put an object in itself */
943  query_name(sack, name_sack, MAX_BUF);
944  if (sack->type != CONTAINER && sack->type != TRANSPORT) {
946  "The %s is not a container.",
947  name_sack);
948  return;
949  }
951  query_name(tmp, name_tmp, MAX_BUF);
953  "You cannot put the %s in the %s.",
954  name_tmp, name_sack);
955  return;
956  }
957  if (tmp->type == CONTAINER) {
958  if (tmp->inv) {
959  if (tmp->slaying)
960  return;
961  /* Eneq(@csd.uu.se): If the object to be dropped is a container
962  * and does not require a key to be opened,
963  * we instead move the contents of that container into the active
964  * container, this is only done if the object has something in it.
965  * If object is container but need a key, just don't do anything
966  */
967  sack2 = tmp;
968  query_name(tmp, name_tmp, MAX_BUF);
970  "You move the items from %s into %s.",
971  name_tmp, name_sack);
972 
973  FOR_INV_PREPARE(tmp, tmp2) {
974  if ((sack->type == CONTAINER && sack_can_hold(op, op->container, tmp2, tmp2->nrof))
975  || (sack->type == TRANSPORT && transport_can_hold(sack, tmp2, tmp2->nrof))) {
976  put_object_in_sack(op, sack, tmp2, 0);
977  } else {
980  "Your %s fills up.",
981  name_sack);
982  break;
983  }
984  } FOR_INV_FINISH();
985  esrv_update_item(UPD_WEIGHT, op, sack2);
986  return;
987  } else {
988  query_name(tmp, name_tmp, MAX_BUF);
990  "You can not put a %s into a %s",
991  name_tmp,
992  name_sack);
993  return;
994  }
995  }
996 
997  /* Don't worry about this for containers - our caller should have
998  * already checked this.
999  */
1000  if (sack->type == CONTAINER && !sack_can_hold(op, sack, tmp, nrof ? nrof : tmp->nrof))
1001  return;
1002 
1003  if (QUERY_FLAG(tmp, FLAG_APPLIED)) {
1005  return;
1006  }
1007 
1008  /* we want to put some portion of the item into the container */
1009  if (nrof && tmp->nrof != nrof) {
1010  char failure[MAX_BUF];
1011 
1012  tmp = object_split(tmp, nrof, failure, sizeof(failure));
1013 
1014  if (!tmp) {
1016  failure);
1017  return;
1018  }
1019  } else
1020  object_remove(tmp);
1021 
1022  if (sack->nrof > 1) {
1023  orig = object_split(sack, sack->nrof-1, NULL, 0);
1024  set_object_face_main(orig);
1025  CLEAR_FLAG(orig, FLAG_APPLIED);
1026  if (sack->env) {
1027  object_insert_in_ob(orig, sack->env);
1028  } else {
1029  object_insert_in_map_at(orig, sack->map, NULL, 0, sack->x, sack->y);
1030  orig->move_off = 0;
1031  }
1032  }
1033 
1034  query_name(tmp, name_tmp, MAX_BUF);
1036  "You put the %s in %s.",
1037  name_tmp, name_sack);
1038 
1039  object_insert_in_ob(tmp, sack);
1041  fix_object(op); /* This is overkill, fix_player() is called somewhere */
1042  /* in object.c */
1043 
1044  /* If a transport, need to update all the players in the transport
1045  * the view of what is in it.
1046  */
1047  if (sack->type == TRANSPORT) {
1048  FOR_INV_PREPARE(sack, tmp)
1049  if (tmp->type == PLAYER)
1050  tmp->contr->socket.update_look = 1;
1051  FOR_INV_FINISH();
1052  } else {
1053  /* update the sacks weight */
1054  esrv_update_item(UPD_WEIGHT, op, sack);
1055  }
1056 }
1057 
1073 object *drop_object(object *op, object *tmp, uint32_t nrof) {
1074  tag_t tmp_tag;
1075 
1076  if (QUERY_FLAG(tmp, FLAG_NO_DROP)) {
1077  return NULL;
1078  }
1079 
1080  if (QUERY_FLAG(tmp, FLAG_APPLIED)) {
1082  return NULL; /* can't unapply it */
1083  }
1084 
1085  if (events_execute_object_event(tmp, EVENT_DROP, op, NULL, NULL, SCRIPT_FIX_ALL) != 0)
1086  return NULL;
1087 
1088  /* ensure the plugin didn't destroy the object */
1089  if (QUERY_FLAG(tmp, FLAG_REMOVED))
1090  return NULL;
1091 
1092  /* We are only dropping some of the items. We split the current objec
1093  * off
1094  */
1095  if (nrof && tmp->nrof != nrof) {
1096  char failure[MAX_BUF];
1097 
1098  tmp = object_split(tmp, nrof, failure, sizeof(failure));
1099  if (!tmp) {
1101  failure);
1102  return NULL;
1103  }
1104  } else
1105  object_remove(tmp);
1106 
1107  if (QUERY_FLAG(tmp, FLAG_STARTEQUIP)) {
1108  char name[MAX_BUF];
1109 
1112  "You drop the %s. The gods who lent it to you retrieve it.",
1113  name);
1115 
1117  fix_object(op);
1118 
1119  return NULL;
1120  }
1121 
1122  /* If SAVE_INTERVAL is commented out, we never want to save
1123  * the player here.
1124  */
1125 #ifdef SAVE_INTERVAL
1126  /* I'm not sure why there is a value check - since the save
1127  * is done every SAVE_INTERVAL seconds, why care the value
1128  * of what he is dropping?
1129  */
1130  if (op->type == PLAYER
1131  && !QUERY_FLAG(tmp, FLAG_UNPAID)
1132  && (tmp->nrof ? tmp->value*tmp->nrof : tmp->value > 2000)
1133  && op->contr->last_save_time+SAVE_INTERVAL <= time(NULL)) {
1134  save_player(op, 1);
1135  op->contr->last_save_time = time(NULL);
1136  }
1137 #endif /* SAVE_INTERVAL */
1138 
1139 
1140  tmp_tag = tmp->count;
1142  if (!object_was_destroyed(tmp, tmp_tag) && !QUERY_FLAG(tmp, FLAG_UNPAID) && tmp->type != MONEY && shop_contains(op)) {
1143  sell_item(tmp, op);
1144  }
1145 
1146  /* Call this before we update the various windows/players. At least
1147  * that we, we know the weight is correct.
1148  */
1149  if (!QUERY_FLAG(op, FLAG_NO_FIX_PLAYER)) {
1150  fix_object(op); /* This is overkill, fix_player() is called somewhere */
1151  /* in object.c */
1152 
1153  /* Need to update weight of player */
1154  if (op->type == PLAYER)
1156  }
1157  return tmp;
1158 }
1159 
1168 void drop(object *op, object *tmp) {
1169  /* Hopeful fix for disappearing objects when dropping from a container -
1170  * somehow, players get an invisible object in the container, and the
1171  * old logic would skip over invisible objects - works fine for the
1172  * playes inventory, but drop inventory wants to use the next value.
1173  */
1174  if (tmp->invisible) {
1175  /* if the following is the case, it must be in an container. */
1176  if (tmp->env && tmp->env->type != PLAYER) {
1177  /* Just toss the object - probably shouldn't be hanging
1178  * around anyways
1179  */
1180  object_remove(tmp);
1182  return;
1183  } else {
1185  if (!tmp->invisible)
1186  break;
1188  }
1189  }
1190 
1191  if (tmp == NULL) {
1193  "You don't have anything to drop.");
1194  return;
1195  }
1196  if (QUERY_FLAG(tmp, FLAG_INV_LOCKED)) {
1198  "This item is locked");
1199  return;
1200  }
1201  if (QUERY_FLAG(tmp, FLAG_NO_DROP)) {
1202  return;
1203  }
1204 
1205  if (op->container) {
1206  if (op->type == PLAYER) {
1207  put_object_in_sack(op, op->container, tmp, op->contr->count);
1208  } else {
1209  put_object_in_sack(op, op->container, tmp, 0);
1210  };
1211  } else {
1212  if (op->type == PLAYER) {
1213  drop_object(op, tmp, op->contr->count);
1214  } else {
1215  drop_object(op, tmp, 0);
1216  };
1217  }
1218  if (op->type == PLAYER)
1219  op->contr->count = 0;
1220 }
1221 
1230 void command_dropall(object *op, const char *params) {
1231  int count = 0;
1232 
1233  if (op->inv == NULL) {
1236  "Nothing to drop!");
1237  return;
1238  }
1239 
1240  if (op->contr)
1241  count = op->contr->count;
1242 
1243  /* Set this so we don't call it for _every_ object that
1244  * is dropped.
1245  */
1247 
1248  /*
1249  * This is the default. Drops everything not locked or considered
1250  * not something that should be dropped.
1251  * Care must be taken that the next item pointer is not to money as
1252  * the drop() routine will do unknown things to it when dropping
1253  * in a shop. --Tero.Pelander@utu.fi
1254  */
1255  if (*params == '\0') {
1256  FOR_INV_PREPARE(op, curinv) {
1257  if (!QUERY_FLAG(curinv, FLAG_INV_LOCKED)
1258  && curinv->type != MONEY
1259  && curinv->type != FOOD
1260  && curinv->type != KEY
1261  && curinv->type != SPECIAL_KEY
1262  && curinv->type != GEM
1263  && !curinv->invisible
1264  && (curinv->type != CONTAINER || op->container != curinv)) {
1265  drop(op, curinv);
1266  if (op->contr)
1267  op->contr->count = count;
1268  }
1269  } FOR_INV_FINISH();
1270  } else if (strcmp(params, "weapons") == 0) {
1271  FOR_INV_PREPARE(op, curinv) {
1272  if (!QUERY_FLAG(curinv, FLAG_INV_LOCKED)
1273  && (curinv->type == WEAPON || curinv->type == BOW || curinv->type == ARROW)) {
1274  drop(op, curinv);
1275  if (op->contr)
1276  op->contr->count = count;
1277  }
1278  } FOR_INV_FINISH();
1279  } else if (strcmp(params, "armor") == 0 || strcmp(params, "armour") == 0) {
1280  FOR_INV_PREPARE(op, curinv) {
1281  if (!QUERY_FLAG(curinv, FLAG_INV_LOCKED)
1282  && (curinv->type == ARMOUR || curinv->type == SHIELD || curinv->type == HELMET)) {
1283  drop(op, curinv);
1284  if (op->contr)
1285  op->contr->count = count;
1286  }
1287  } FOR_INV_FINISH();
1288  } else if (strcmp(params, "food") == 0) {
1289  FOR_INV_PREPARE(op, curinv) {
1290  if (!QUERY_FLAG(curinv, FLAG_INV_LOCKED)
1291  && (curinv->type == FOOD || curinv->type == DRINK)) {
1292  drop(op, curinv);
1293  if (op->contr)
1294  op->contr->count = count;
1295  }
1296  } FOR_INV_FINISH();
1297  } else if (strcmp(params, "flesh") == 0) {
1298  FOR_INV_PREPARE(op, curinv) {
1299  if (!QUERY_FLAG(curinv, FLAG_INV_LOCKED)
1300  && (curinv->type == FLESH)) {
1301  drop(op, curinv);
1302  if (op->contr)
1303  op->contr->count = count;
1304  }
1305  } FOR_INV_FINISH();
1306  } else if (strcmp(params, "misc") == 0) {
1307  FOR_INV_PREPARE(op, curinv) {
1308  if (!QUERY_FLAG(curinv, FLAG_INV_LOCKED)
1309  && !QUERY_FLAG(curinv, FLAG_APPLIED)) {
1310  switch (curinv->type) {
1311  case BOOK:
1312  case SPELLBOOK:
1313  case GIRDLE:
1314  case AMULET:
1315  case RING:
1316  case CLOAK:
1317  case BOOTS:
1318  case GLOVES:
1319  case BRACERS:
1320  case SCROLL:
1321  case ARMOUR_IMPROVER:
1322  case WEAPON_IMPROVER:
1323  case WAND:
1324  case ROD:
1325  case POTION:
1326  drop(op, curinv);
1327  if (op->contr)
1328  op->contr->count = count;
1329  break;
1330 
1331  default:
1332  break;
1333  }
1334  }
1335  } FOR_INV_FINISH();
1336  }
1337  op->contr->socket.update_look = 1;
1339  /* call it now, once */
1340  fix_object(op);
1341  /* Need to update weight of player. Likewise, only do it once */
1342  if (op->type == PLAYER)
1344 }
1345 
1354 void command_drop(object *op, const char *params) {
1355  int did_one = 0;
1356  int missed = 0;
1357 
1358  if (*params == '\0') {
1360  "Drop what?");
1361  return;
1362  }
1363 
1364  matcher_params mp;
1365  item_matcher matcher = make_matcher(op, params, &mp);
1366  if (!matcher) {
1367  return;
1368  }
1369 
1371 
1372  FOR_INV_PREPARE(op, tmp) {
1373  if (QUERY_FLAG(tmp, FLAG_NO_DROP) || tmp->invisible)
1374  continue;
1375  if ((*matcher)(op, &mp, tmp)) {
1376  if (QUERY_FLAG(tmp, FLAG_INV_LOCKED)) {
1377  missed++;
1378  } else {
1379  drop(op, tmp);
1380  }
1381  did_one = 1;
1382  }
1383  } FOR_INV_FINISH();
1384  if (!did_one)
1386  "Nothing to drop.");
1387  if (missed == 1)
1389  "One item couldn't be dropped because it was locked.");
1390  else if (missed > 1)
1392  "%d items couldn't be dropped because they were locked.",
1393  missed);
1394 
1395  /* Now update player and send information. */
1397  fix_object(op);
1398  if (op->type == PLAYER) {
1399  op->contr->count = 0;
1401  }
1402 }
1403 
1412 static void empty_container(object *container, object *pl) {
1413  int left = 0;
1414  char name[MAX_BUF];
1415 
1416  if (!container->inv)
1417  return;
1418 
1419  FOR_INV_PREPARE(container, inv) {
1420  object *next;
1421 
1422  if (QUERY_FLAG(inv, FLAG_INV_LOCKED)) {
1423  /* you can have locked items in container. */
1424  left++;
1425  continue;
1426  }
1427  next = inv->below;
1428  drop(pl, inv);
1429  if (inv->below == next)
1430  /* item couldn't be dropped for some reason. */
1431  left++;
1432  } FOR_INV_FINISH();
1433  esrv_update_item(UPD_WEIGHT, pl, container);
1434 
1435  query_name(container, name, sizeof(name));
1436  if (left)
1437  draw_ext_info_format(NDI_UNIQUE, 0, pl, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS, "You empty the %s except %d items.", name, left);
1438  else
1440 }
1441 
1450 void command_empty(object *op, const char *params) {
1451  object *container;
1452 
1453  if (*params == '\0') {
1455  "Empty what?");
1456  return;
1457  }
1458 
1459  if (strcmp(params, "all") == 0) {
1461  if (inv->type == CONTAINER)
1463  FOR_INV_FINISH();
1464  return;
1465  }
1466 
1467  container = find_best_object_match(op, params);
1468  if (!container) {
1470  "No such item.");
1471  return;
1472  }
1473  if (container->type != CONTAINER) {
1475  "This is not a container!");
1476  return;
1477  }
1478  empty_container(container, op);
1479 }
1480 
1489 void command_examine(object *op, const char *params) {
1490  if (*params == '\0') {
1492  if (LOOK_OBJ(tmp)) {
1493  examine(op, tmp);
1494  break;
1495  }
1496  FOR_BELOW_FINISH();
1497  } else {
1498  object *tmp = find_best_object_match(op, params);
1499 
1500  if (tmp)
1501  examine(op, tmp);
1502  else
1504  "Could not find an object that matches %s",
1505  params);
1506  }
1507 }
1508 
1520 object *find_marked_object(object *op) {
1521  if (!op || !op->contr || !op->contr->mark)
1522  return NULL;
1523 
1524  /* This may seem like overkill, but we need to make sure that they
1525  * player hasn't dropped the item. We use count on the off chance that
1526  * an item got reincarnated at some point.
1527  */
1528  /*
1529  FOR_INV_PREPARE(op, tmp) {
1530  if (tmp->invisible)
1531  continue;
1532  if (tmp == op->contr->mark) {
1533  if (tmp->count == op->contr->mark_count)
1534  return tmp;
1535  else {
1536  op->contr->mark = NULL;
1537  op->contr->mark_count = 0;
1538  return NULL;
1539  }
1540  }
1541  } FOR_INV_FINISH();
1542  */
1543  /* Try a different way of doing this
1544  * We check the environment of the marked object
1545  * to make sure it is still in the player's inventory.
1546  * In addition, we ensure there is the correct tag for that item.
1547  *
1548  * Daniel Hawkins 2018-10-23
1549  */
1550  if (op->contr->mark->env == op && op->contr->mark->count == op->contr->mark_count)
1551  return op->contr->mark;
1552  // Otherwise reset the mark, since it is no longer valid.
1553  op->contr->mark = NULL;
1554  op->contr->mark_count = 0;
1555  return NULL;
1556 }
1557 
1567 void command_mark(object *op, const char *params) {
1568  char name[MAX_BUF];
1569 
1570  if (!op->contr)
1571  return;
1572  if (*params == '\0') {
1573  object *mark = find_marked_object(op);
1574  if (!mark)
1576  "You have no marked object.");
1577  else {
1578  query_name(mark, name, MAX_BUF);
1580  "%s is marked.",
1581  name);
1582  }
1583  } else {
1584  object *mark1 = find_best_object_match(op, params);
1585 
1586  if (!mark1) {
1588  "Could not find an object that matches %s",
1589  params);
1590  return;
1591  } else {
1592  op->contr->mark = mark1;
1593  op->contr->mark_count = mark1->count;
1594  query_name(mark1, name, MAX_BUF);
1596  "Marked item %s",
1597  name);
1598  return;
1599  }
1600  }
1601  /*shouldnt get here */
1602 }
1603 
1614 void examine_monster(object *op, object *tmp, int level) {
1615  object *mon = HEAD(tmp), *probe;
1616 
1617  if (QUERY_FLAG(mon, FLAG_UNDEAD))
1619  "It is an undead force.");
1620  if (mon->level > op->level)
1622  "It is likely more powerful than you.");
1623  else if (mon->level < op->level)
1625  "It is likely less powerful than you.");
1626  else
1628  "It is probably as powerful as you.");
1629 
1630  if (mon->attacktype&AT_ACID)
1632  "You smell an acrid odor.");
1633 
1634  /* Anyone know why this used to use the clone value instead of the
1635  * maxhp field? This seems that it should give more accurate results.
1636  */
1637  switch ((mon->stats.hp+1)*4/(mon->stats.maxhp+1)) {
1638  /* From 0-4+, since hp can be higher than maxhp if defined in map. */
1639  case 0:
1641  "It is critically wounded.");
1642  break;
1643 
1644  case 1:
1646  "It is in a bad shape.");
1647  break;
1648 
1649  case 2:
1651  "It is hurt.");
1652  break;
1653 
1654  case 3:
1656  "It is somewhat hurt.");
1657  break;
1658 
1659  default:
1661  "It is in excellent shape.");
1662  break;
1663  }
1664  if (object_present_in_ob(POISONING, mon) != NULL)
1666  "It looks very ill.");
1667 
1668  if (level < 10)
1669  return;
1671 
1672  if (level < 15)
1673  return;
1674 
1675  probe = object_find_by_type_and_name(mon, FORCE, "probe_force");
1676  if (probe != NULL && probe->level > level)
1677  return;
1678 
1679  if (probe == NULL) {
1681  free_string(probe->name);
1682  probe->name = add_string("probe_force");
1686  fix_object(mon);
1687  }
1688  probe->level = level;
1689  if (level / 10 > probe->duration)
1690  probe->duration = level / 10;
1691 }
1692 
1702 void examine(object *op, object *tmp) {
1703  char buf[VERY_BIG_BUF];
1704  int in_shop;
1705  int i, exp = 0, conn;
1706 
1707  /* we use this to track how far along we got with trying to identify an item,
1708  * so that we can give the appropriate message to the player */
1709  int id_attempted = 0;
1710  char prefix[MAX_BUF] = "That is";
1711  const typedata *tmptype;
1712  object *skill;
1713 
1714  buf[0] = '\0';
1715 
1716  if (tmp == NULL || tmp->type == CLOSE_CON)
1717  return;
1718  tmptype = get_typedata(tmp->type);
1719  if (!tmptype) {
1720  LOG(llevError, "Attempted to examine item %d with type %d, which is invalid", tmp->count, tmp->type);
1721  return;
1722  }
1723  /* first of all check whether this is an item we need to identify, and identify it as best we can.*/
1724  if (!QUERY_FLAG(tmp, FLAG_IDENTIFIED)) {
1725  /* We will look for magic status, cursed status and then try to do a full skill-based ID, in that order */
1727  if (skill && (object_can_pick(op, tmp))) {
1728  exp = detect_magic_on_item(op, tmp, skill);
1729  if (exp) {
1730  change_exp(op, exp, skill->skill, SK_SUBTRACT_SKILL_EXP);
1732  "You discover mystic forces on %s", tmp->nrof <= 1?"that item":"those items" );
1733  }
1734  }
1736  /* Cauldrons are a special case of item where it should be possible to detect a curse */
1737  if (skill && (object_can_pick(op, tmp) || QUERY_FLAG(tmp, FLAG_IS_CAULDRON))) {
1738  exp = detect_curse_on_item(op, tmp, skill);
1739  if (exp) {
1740  change_exp(op, exp, skill->skill, SK_SUBTRACT_SKILL_EXP);
1742  "You have a bad feeling about %s", tmp->nrof <= 1?"that item":"those items" );
1743  }
1744  }
1746 
1747  id_attempted = 1;
1748  skill = find_skill_by_number(op, tmptype->identifyskill);
1749  if (skill) {
1750  id_attempted = 2;
1751 
1752  /* identify_object_with_skill() may merge tmp with another
1753  * object, so once that happens, we really can not do
1754  * any further processing with tmp. It would be possible
1755  * to modify identify_object_with_skill() to return
1756  * the merged object, but it is currently set to return
1757  * exp, so it would have to do it via modifying the
1758  * passed in value, but many other consumers would
1759  * need to be modified for that.
1760  */
1761  exp = identify_object_with_skill(tmp, op, skill, 1);
1762  if (exp) {
1763  change_exp(op, exp, skill->skill, SK_SUBTRACT_SKILL_EXP);
1764  return;
1765  }
1766  }
1767  if(!exp) {
1768  /* The primary id skill didn't work, let's try the secondary one */
1769  skill = find_skill_by_number(op, tmptype->identifyskill2);
1770  if (skill) {
1771  /* if we've reached here, then the first skill will have been attempted
1772  * and failed; this will have set FLAG_NO_SKILL_IDENT we want to clear
1773  * that now, and try with the secondary ID skill, if it fails, then the
1774  * flag will be reset anyway, if it succeeds, it won't matter.*/
1776  id_attempted = 2;
1777  exp = identify_object_with_skill(tmp, op, skill, 1);
1778  if (exp) {
1779  change_exp(op, exp, skill->skill, SK_SUBTRACT_SKILL_EXP);
1780  return;
1781  }
1782  }
1783  }
1784  }
1785  }
1786  if (!exp) {
1787  /* if we did get exp we'll already have propulated prefix */
1788  if (tmptype->identifyskill || tmptype->identifyskill2) {
1789  switch (id_attempted) {
1790  case 1:
1791  snprintf(prefix, MAX_BUF, "You lack the skill to understand %s:", tmp->nrof <= 1?"that fully; it is":"those fully, they are");
1792  break;
1793  case 2:
1794  snprintf(prefix, MAX_BUF, "You fail to understand %s:", tmp->nrof <= 1?"that fully; it is":"those fully, they are");
1795  break;
1796  default:
1797  snprintf(prefix, MAX_BUF, "%s:", tmp->nrof <= 1?"That is":"Those are");
1798  }
1799  } else snprintf(prefix, MAX_BUF, "%s:", tmp->nrof <= 1?"That is":"Those are");
1800  }
1801  /* now we need to get the rest of the object description */
1802  ob_describe(tmp, op, 1, buf, sizeof(buf));
1803 
1805  "%s %s", prefix, buf);
1806  buf[0] = '\0';
1807  if (tmp->custom_name) {
1809  "You name it %s",
1810  tmp->custom_name);
1811  }
1812 
1813  switch (tmp->type) {
1814  case SKILLSCROLL:
1815  case SKILL_TOOL:
1816  // Embedded skills are stored as an archetype name and don't get reified
1817  // until the player actually reads/equips the object, so we need to
1818  // handle it differently from spells, which are stored in the inv.
1819  if (!tmp->skill) break; // Blank skill scroll, somehow.
1820  archetype *skill = get_archetype_by_skill_name(tmp->skill, SKILL);
1821  if (!skill) {
1822  // Skill name doesn't correspond to any actual skill.
1824  "Unfortunately the scroll is damaged and unreadable.");
1825  break;
1826  }
1827  // Only print the flavor text once we have identified.
1828  if (is_identified(tmp) && skill->clone.msg) {
1830  stringbuffer_append_string(sb, skill->clone.msg);
1832  char *const fluff = stringbuffer_finish(sb);
1833  // SPELL_INFO is not a perfect match here, but it should display in the
1834  // same manner as the spell descriptions below and there's no SKILL_INFO
1835  // message type.
1837  free(fluff);
1838  }
1839  break;
1840 
1841  case SPELLBOOK:
1842  case SCROLL:
1843  case WAND:
1844  case ROD:
1845  case POTION:
1846  // Only print the flavor text once we have identified.
1847  if (is_identified(tmp) && tmp->inv && tmp->inv->msg) {
1848  // If the embedded spell has a msg, display it here so that the
1849  // player knows what it does before they actually read/use the item.
1850  // Strip trailing newlines so that the output of examine() is
1851  // contiguous.
1852  // TODO: It might be better to strip the newlines in object_set_msg
1853  // and append them at print time, rather than ensuring that the msg
1854  // is newline-terminated and stripping off the newlines when we don't
1855  // want them; C string handling makes the latter a lot less convenient.
1857  stringbuffer_append_string(sb, tmp->inv->msg);
1859  char *const fluff = stringbuffer_finish(sb);
1861  free(fluff);
1862  }
1863  if (tmp->type == WAND && is_identified(tmp)) {
1864  snprintf(buf, sizeof(buf), "It has %d charges left.", tmp->stats.food);
1865  }
1866  break;
1867 
1868  case BOOK:
1869  if (tmp->msg != NULL)
1870  snprintf(buf, sizeof(buf), "Something is written in it.");
1871  break;
1872 
1873  case CONTAINER:
1874  if (tmp->race != NULL) {
1875  if (tmp->weight_limit && tmp->stats.Str < 100)
1876  snprintf(buf, sizeof(buf), "It can hold only %s and its weight limit is %.1f kg.", tmp->race, tmp->weight_limit/(10.0*(100-tmp->stats.Str)));
1877  else
1878  snprintf(buf, sizeof(buf), "It can hold only %s.", tmp->race);
1879  } else
1880  if (tmp->weight_limit && tmp->stats.Str < 100)
1881  snprintf(buf, sizeof(buf), "Its weight limit is %.1f kg.", tmp->weight_limit/(10.0*(100-tmp->stats.Str)));
1882  break;
1883  }
1884 
1885  if (buf[0] != '\0')
1887  buf);
1888 
1889  // TODO: combine with weight and properly pluralize, so you get:
1890  // It is made of stone and weighs 15.0 kg.
1891  // They are made of paper and weigh 3 kg.
1892  if (tmp->materialname != NULL && !tmp->msg) {
1894  "It is made of: %s.",
1895  tmp->materialname);
1896  }
1897  /* Where to wear this item */
1898  for (i = 0; i < NUM_BODY_LOCATIONS; i++) {
1899  if (tmp->body_info[i]) {
1900  if (op->body_info[i]) {
1901  if (tmp->body_info[i] < -1) {
1903  "%s %s (%d)", tmp->nrof > 1 ? "They go" : "It goes",
1904  body_locations[i].use_name, -tmp->body_info[i]);
1905  } else {
1907  "%s %s", tmp->nrof > 1 ? "They go" : "It goes",
1909  }
1910  } else {
1912  "%s %s", tmp->nrof > 1 ? "They go" : "It goes",
1914  }
1915  }
1916  }
1917 
1918  if (tmp->weight) {
1919  snprintf(buf, sizeof(buf), tmp->nrof > 1 ? "They weigh %3.3f kg." : "It weighs %3.3f kg.", tmp->weight*((float)(tmp->nrof ? tmp->nrof : 1)/1000.0));
1921  buf);
1922  }
1923 
1924  in_shop = shop_contains(op);
1925 
1926  if (tmp->value && !QUERY_FLAG(tmp, FLAG_STARTEQUIP) && !QUERY_FLAG(tmp, FLAG_NO_PICK)) {
1927  char *value = cost_approx_str(tmp, op);
1928  snprintf(buf, sizeof(buf), "You reckon %s worth %s.", tmp->nrof > 1 ? "they are" : "it is", value);
1929  free(value);
1931  buf);
1932  if (in_shop) {
1933  if (QUERY_FLAG(tmp, FLAG_UNPAID)) {
1935  snprintf(buf, sizeof(buf), "%s would cost you %s.", tmp->nrof > 1 ? "They" : "It", value);
1936  free(value);
1937  } else {
1939  snprintf(buf, sizeof(buf), "You are offered %s for %s.", value, tmp->nrof > 1 ? "them" : "it");
1940  free(value);
1941  }
1943  buf);
1944  }
1945  }
1946 
1947  if (QUERY_FLAG(tmp, FLAG_MONSTER))
1948  examine_monster(op, tmp, 0);
1949 
1950  /* Is this item buildable? */
1953  "This is a buildable item.");
1954  if (QUERY_FLAG(tmp, FLAG_IS_LINKED)){
1955  conn = get_button_value(tmp);
1956  if (conn) {
1957  FOR_INV_PREPARE(op, tmp_inv) {
1958  if (tmp_inv->type == FORCE && tmp_inv->slaying != NULL
1959  && strcmp(tmp_inv->slaying, op->map->path) == 0
1960  && tmp_inv->msg != NULL
1961  && tmp_inv->path_attuned == (uint32_t) conn) {
1962 
1964  MSG_TYPE_COMMAND_EXAMINE, "Connected with: %s",
1965  tmp_inv->msg);
1966 
1967  break;
1968  }
1969  } FOR_INV_FINISH();
1970  }
1971  }
1972  }
1973 
1974  /* Does the object have a message? Don't show message for all object
1975  * types - especially if the first entry is a match
1976  */
1977  if (tmp->msg
1978  && tmp->type != EXIT
1979  && tmp->type != BOOK
1980  && tmp->type != CORPSE
1981  && !tmp->move_on
1982  && strncasecmp(tmp->msg, "@match", 6)) {
1983  /* This is just a hack so when identifying the items, we print
1984  * out the extra message. Do this only for "identifiable types", e.g.
1985  * we don't want to print this message when the player looks at a
1986  * locked door (where msg is used to store the message they get when
1987  * trying to force it open).
1988  *
1989  * Also, don't print the message for the object unless it has been identified
1990  * -- SilverNexus 2015-05-20
1991  */
1994  "The object has a story:");
1995 
1997  tmp->msg);
1998  }
1999  }
2001  " "); /* Blank line */
2002 
2003  if (is_identified(tmp)) {
2005  }
2006 }
2007 
2016 void inventory(object *op, object *inv) {
2017  const char *in;
2018  int items = 0, length;
2019  char weight[MAX_BUF], name[MAX_BUF];
2020 
2021  if (inv == NULL && op == NULL) {
2023  "Inventory of what object?");
2024  return;
2025  }
2026  FOR_INV_PREPARE(inv ? inv : op, tmp)
2027  if ((!tmp->invisible && (inv == NULL || inv->type == CONTAINER || QUERY_FLAG(tmp, FLAG_APPLIED)))
2028  || !op || QUERY_FLAG(op, FLAG_WIZ))
2029  items++;
2030  FOR_INV_FINISH();
2031  if (inv == NULL) { /* player's inventory */
2032  if (items == 0) {
2034  "You carry nothing.");
2035  return;
2036  } else {
2037  length = 28;
2038  in = "";
2040  "Inventory:");
2041  }
2042  } else {
2043  if (items == 0)
2044  return;
2045  else {
2046  length = 28;
2047  in = " ";
2048  }
2049  }
2050  FOR_INV_PREPARE(inv ? inv : op, tmp) {
2051  if ((!op || !QUERY_FLAG(op, FLAG_WIZ))
2052  && (tmp->invisible || (inv && inv->type != CONTAINER && !QUERY_FLAG(tmp, FLAG_APPLIED))))
2053  continue;
2054  query_weight(tmp, weight, MAX_BUF);
2056  if (!op || QUERY_FLAG(op, FLAG_WIZ))
2058  "[fixed]%s- %-*.*s (%5d) %-8s",
2059  in, length, length, name, tmp->count, weight);
2060  else
2062  "[fixed]%s- %-*.*s %-8s",
2063  in, length+8, length+8, name, weight);
2064  } FOR_INV_FINISH();
2065  if (!inv && op) {
2066  query_weight(op, weight, MAX_BUF);
2068  "[fixed]%-*s %-8s",
2069  41, "Total weight :", weight);
2070  }
2071 }
2072 
2081 static void display_new_pickup(const object *op, int old) {
2082  int i = op->contr->mode;
2083 
2084  esrv_send_pickup(op->contr);
2085 
2086  if (!(i&PU_NEWMODE) || !(i&PU_DEBUG)) {
2087  if ((old & PU_INHIBIT) != (op->contr->mode & PU_INHIBIT)) {
2089  "Pickup is %s.", (old & PU_INHIBIT) ? "active" : "inhibited");
2090  }
2091  return;
2092  }
2093 
2095  "%d NEWMODE",
2096  i&PU_NEWMODE ? 1 : 0);
2098  "%d DEBUG",
2099  i&PU_DEBUG ? 1 : 0);
2101  "%d INHIBIT",
2102  i&PU_INHIBIT ? 1 : 0);
2104  "%d STOP",
2105  i&PU_STOP ? 1 : 0);
2106 
2108  "%d <= x pickup weight/value RATIO (0==off)",
2109  (i&PU_RATIO)*5);
2110 
2112  "%d FOOD",
2113  i&PU_FOOD ? 1 : 0);
2115  "%d DRINK",
2116  i&PU_DRINK ? 1 : 0);
2118  "%d VALUABLES",
2119  i&PU_VALUABLES ? 1 : 0);
2120 
2122  "%d BOW",
2123  i&PU_BOW ? 1 : 0);
2125  "%d ARROW",
2126  i&PU_ARROW ? 1 : 0);
2127 
2129  "%d HELMET",
2130  i&PU_HELMET ? 1 : 0);
2132  "%d SHIELD",
2133  i&PU_SHIELD ? 1 : 0);
2135  "%d ARMOUR",
2136  i&PU_ARMOUR ? 1 : 0);
2137 
2139  "%d BOOTS",
2140  i&PU_BOOTS ? 1 : 0);
2142  "%d GLOVES",
2143  i&PU_GLOVES ? 1 : 0);
2145  "%d CLOAK",
2146  i&PU_CLOAK ? 1 : 0);
2148  "%d KEY",
2149  i&PU_KEY ? 1 : 0);
2150 
2152  "%d MISSILEWEAPON",
2153  i&PU_MISSILEWEAPON ? 1 : 0);
2155  "%d MELEEWEAPON",
2156  i&PU_MELEEWEAPON ? 1 : 0);
2158  "%d MAGICAL",
2159  i&PU_MAGICAL ? 1 : 0);
2161  "%d POTION",
2162  i&PU_POTION ? 1 : 0);
2163 
2165  "%d SPELLBOOK",
2166  i&PU_SPELLBOOK ? 1 : 0);
2168  "%d SKILLSCROLL",
2169  i&PU_SKILLSCROLL ? 1 : 0);
2171  "%d READABLES",
2172  i&PU_READABLES ? 1 : 0);
2174  "%d MAGICDEVICE",
2175  i&PU_MAGIC_DEVICE ? 1 : 0);
2176 
2178  "%d NOT CURSED",
2179  i&PU_NOT_CURSED ? 1 : 0);
2180 
2182  "%d JEWELS",
2183  i&PU_JEWELS ? 1 : 0);
2184 
2186  "%d FLESH",
2187  i&PU_FLESH ? 1 : 0);
2188 
2190  "%d CONTAINER",
2191  i&PU_CONTAINER ? 1 : 0);
2192 
2194  "%d CURSED",
2195  i&PU_CURSED ? 1 : 0);
2196 
2198  "");
2199 }
2200 
2210 void command_pickup(object *op, const char *params) {
2211  uint32_t i;
2212 
2213  if (*params == '\0') {
2214  /* if the new mode is used, just print the settings */
2215  if (op->contr->mode&PU_NEWMODE) {
2216  display_new_pickup(op, op->contr->mode);
2217  return;
2218  }
2219  if (1)
2220  LOG(llevDebug, "command_pickup: !params\n");
2221  set_pickup_mode(op, op->contr->mode > 6 ? 0 : op->contr->mode+1);
2222  return;
2223  }
2224 
2225  while (*params == ' ')
2226  params++;
2227 
2228  if (*params == '+' || *params == '-' || *params == '!') {
2229  int index = get_pickup_mode_index(params + 1);
2230 
2231  if (index != -1) {
2232  int old = op->contr->mode;
2233  i = op->contr->mode;
2234  if (!(i&PU_NEWMODE))
2235  i = PU_NEWMODE;
2236  if (*params == '+')
2237  i = i|pickup_modes[index];
2238  else if (*params == '-')
2239  i = i&~pickup_modes[index];
2240  else {
2241  if (i&pickup_modes[index])
2242  i = i&~pickup_modes[index];
2243  else
2244  i = i|pickup_modes[index];
2245  }
2246  op->contr->mode = i;
2247  display_new_pickup(op, old);
2248  return;
2249  }
2251  "Pickup: invalid item %s\n",
2252  params);
2253  return;
2254  }
2255 
2256  if (sscanf(params, "%u", &i) != 1) {
2257  if (1)
2258  LOG(llevDebug, "command_pickup: params==NULL\n");
2260  "Usage: pickup <0-7> or <value_density> .");
2261  return;
2262  }
2263  set_pickup_mode(op, i);
2264  display_new_pickup(op, op->contr->mode);
2265 }
2266 
2275 static void set_pickup_mode(const object *op, int i) {
2276  op->contr->mode = i;
2277  switch (op->contr->mode) {
2278  case 0:
2280  "Mode: Don't pick up.");
2281  break;
2282 
2283  case 1:
2285  "Mode: Pick up one item.");
2286  break;
2287 
2288  case 2:
2290  "Mode: Pick up one item and stop.");
2291  break;
2292 
2293  case 3:
2295  "Mode: Stop before picking up.");
2296  break;
2297 
2298  case 4:
2300  "Mode: Pick up all items.");
2301  break;
2302 
2303  case 5:
2305  "Mode: Pick up all items and stop.");
2306  break;
2307 
2308  case 6:
2310  "Mode: Pick up all magic items.");
2311  break;
2312 
2313  case 7:
2315  "Mode: Pick up all coins and gems");
2316  break;
2317  }
2318 }
2319 
2328 void command_search_items(object *op, const char *params) {
2329  if (settings.search_items == FALSE)
2330  return;
2331 
2332  if (!params || *params == '\0') {
2333  if (op->contr->search_str[0] == '\0') {
2335  "Example: search magic+1 "
2336  "Would automatically pick up all "
2337  "items containing the word 'magic+1'.");
2338  return;
2339  }
2340  op->contr->search_str[0] = '\0';
2342  "Search mode turned off.");
2343  fix_object(op);
2344  return;
2345  }
2346  if ((int)strlen(params) >= MAX_BUF) {
2348  "Search string too long.");
2349  return;
2350  }
2351  strcpy(op->contr->search_str, params);
2353  "Searching for '%s'.",
2354  op->contr->search_str);
2355  fix_object(op);
2356 }
2357 
2373 void command_rename_item(object *op, const char *params) {
2374  char buf[VERY_BIG_BUF], name[MAX_BUF];
2375  tag_t itemnumber;
2376  object *item = NULL;
2377  object *tmp;
2378  char *closebrace;
2379  size_t counter;
2380 
2381  if (*params != '\0') {
2382  /* Let's skip white spaces */
2383  while (' ' == *params)
2384  params++;
2385 
2386  /* Checking the first part */
2387  itemnumber = atoi(params);
2388  if (itemnumber != 0) {
2390  if (inv->count == itemnumber && !inv->invisible) {
2391  item = inv;
2392  break;
2393  }
2394  FOR_INV_FINISH();
2395  if (!item) {
2397  "Tried to rename an invalid item.");
2398  return;
2399  }
2400  while (isdigit(*params) || ' ' == *params)
2401  params++;
2402  } else if ('<' == *params) {
2403  /* Got old name, let's get it & find appropriate matching item */
2404  closebrace = strchr(params, '>');
2405  if (!closebrace) {
2407  "Syntax error!");
2408  return;
2409  }
2410  /* Sanity check for buffer overruns */
2411  if (closebrace-params > 127) {
2413  "Old name too long (up to 127 characters allowed)!");
2414  return;
2415  }
2416  /* Copy the old name */
2417  snprintf(buf, sizeof(buf), "%.*s", (int)(closebrace-(params+1)), params+1);
2418 
2419  /* Find best matching item */
2421  if (!item) {
2423  "Could not find a matching item to rename.");
2424  return;
2425  }
2426 
2427  /* Now need to move pointer to just after > */
2428  params = closebrace+1;
2429  while (' ' == *params)
2430  params++;
2431  } else {
2432  /* Use marked item */
2434  if (!item) {
2436  "No marked item to rename.");
2437  return;
2438  }
2439  }
2440 
2441  /* Now let's find the new name */
2442  if (!strncmp(params, "to ", 3)) {
2443  params += 3;
2444  while (' ' == *params)
2445  params++;
2446  if ('<' != *params) {
2448  "Syntax error, expecting < at start of new name!");
2449  return;
2450  }
2451  closebrace = strchr(params+1, '>');
2452  if (!closebrace) {
2454  "Syntax error, expecting > at end of new name!");
2455  return;
2456  }
2457 
2458  /* Sanity check for buffer overruns */
2459  if (closebrace-params > 127) {
2461  "New name too long (up to 127 characters allowed)!");
2462  return;
2463  }
2464 
2465  /* Copy the new name */
2466  snprintf(buf, sizeof(buf), "%.*s", (int)(closebrace-(params+1)), params+1);
2467 
2468  /* Let's check it for weird characters */
2469  for (counter = 0; counter < strlen(buf); counter++) {
2470  if (isalnum(buf[counter]))
2471  continue;
2472  if (' ' == buf[counter])
2473  continue;
2474  if ('\'' == buf[counter])
2475  continue;
2476  if ('+' == buf[counter])
2477  continue;
2478  if ('_' == buf[counter])
2479  continue;
2480  if ('-' == buf[counter])
2481  continue;
2482 
2483  /* If we come here, then the name contains an invalid character...
2484  * tell the player & exit
2485  */
2487  "Invalid new name!");
2488  return;
2489  }
2490  } else {
2491  /* If param contains something, then syntax error... */
2492  if (strlen(params)) {
2494  "Syntax error, expected 'to <' after old name!");
2495  return;
2496  }
2497  /* New name is empty */
2498  buf[0] = '\0';
2499  }
2500  } else {
2501  /* Last case: *params=='\0' */
2503  if (!item) {
2505  "No marked item to rename.");
2506  return;
2507  }
2508  buf[0] = '\0';
2509  }
2510 
2511  /* Coming here, everything is fine... */
2512  if (!strlen(buf)) {
2513  /* Clear custom name */
2514  if (item->custom_name == NULL) {
2516  "This item has no custom name.");
2517  return;
2518  }
2519 
2520  FREE_AND_CLEAR_STR(item->custom_name);
2521  query_base_name(item, item->nrof > 1 ? 1 : 0, name, MAX_BUF);
2523  "You stop calling your %s with weird names.",
2524  name);
2525  } else {
2526  if (item->custom_name != NULL && strcmp(item->custom_name, buf) == 0) {
2527  query_base_name(item, item->nrof > 1 ? 1 : 0, name, MAX_BUF);
2529  "You keep calling your %s %s.",
2530  name, buf);
2531  return;
2532  }
2533 
2534  /* Set custom name */
2535  FREE_AND_COPY(item->custom_name, buf);
2536 
2537  query_base_name(item, item->nrof > 1 ? 1 : 0, name, MAX_BUF);
2539  "Your %s will now be called %s.",
2540  name, buf);
2541  }
2542 
2543  tmp = object_merge(item, NULL);
2544  if (tmp == NULL) {
2545  /* object was not merged - if it was, object_merge() handles updating for us. */
2547  }
2548 }
2549 
2558 void command_lock_item(object *op, const char *params) {
2559  object *item;
2560  object *tmp;
2561  char name[HUGE_BUF];
2562 
2563  if (*params == '\0' || strlen(params) == 0) {
2565  "Lock what item?");
2566  return;
2567  }
2568 
2570  if (!item) {
2572  "Can't find any matching item.");
2573  return;
2574  }
2575 
2579  "Unlocked %s.", name);
2581  } else {
2583  "Locked %s.", name);
2585  }
2586 
2587  tmp = object_merge(item, NULL);
2588  if (tmp == NULL) {
2589  /* object was not merged, if it was object_merge() handles updates for us */
2591  }
2592 }
2593 
2601 void command_use(object *op, const char *params) {
2602  char *with, copy[MAX_BUF];
2603  object *first, *second/*, *add*/;
2604  /*archetype *arch;*/
2605  /*int count;*/
2606  /*sstring data;*/
2607  recipe *transformation;
2608 
2609  if (!IS_PLAYER(op))
2610  return;
2611 
2612  strlcpy(copy, params, sizeof(copy));
2613  with = strstr(copy, " with ");
2614  if (!with) {
2615  draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_FAILURE, "Syntax is use <item> with <item>.");
2616  return;
2617  }
2618 
2619  with[0] = '\0';
2620  with = with+strlen(" with ");
2621 
2622  first = find_best_object_match(op, copy);
2623  if (!first) {
2625  return;
2626  }
2627  second = find_best_object_match(op, with);
2628  if (!second) {
2630  return;
2631  }
2632 
2633  transformation = NULL;
2634  while ((transformation = find_recipe_for_tool(first->arch->name, transformation))) {
2636  if (transformation->ingred_count != 1)
2637  continue;
2638 
2639 /* LOG(llevDebug, "use: check %s\n", transformation->title);*/
2640  if (strcmp(second->name, transformation->ingred->name) == 0) {
2642  object *generated = create_archetype(transformation->arch_name[0]);
2643  if (transformation->yield)
2644  generated->nrof = transformation->yield;
2645  object_insert_in_ob(generated, op);
2646  /*draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_FAILURE, "Found recipe %s", transformation->title);*/
2648  return;
2649  }
2650  }
2652  return;
2653 
2654  /*
2655  snprintf(copy, sizeof(copy), "on_use_with_%s", first->arch->name);
2656  data = object_get_value(second, copy);
2657  if (!data) {
2658  snprintf(copy, sizeof(copy), "on_use_with_%d_%d", first->type, first->subtype);
2659  data = object_get_value(second, copy);
2660  if (!data) {
2661  snprintf(copy, sizeof(copy), "on_use_with_%d", first->type);
2662  data = object_get_value(second, copy);
2663  if (!data) {
2664  draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_FAILURE, "Nothing happens.");
2665  return 1;
2666  }
2667  }
2668  }
2669 
2670  while (data != NULL) {
2671  if (strncmp(data, "add ", 4) == 0) {
2672  data += 4;
2673  if (isdigit(*data)) {
2674  count = atol(data);
2675  data = strchr(data, ' ')+1;
2676  } else
2677  count = 1;
2678  with = strchr(data, ' ');
2679  if (!with) {
2680  strncpy(copy, data, sizeof(copy));
2681  data = NULL;
2682  } else {
2683  *with = '\0';
2684  strncpy(copy, data, sizeof(copy));
2685  data += strlen(copy)+1;
2686  }
2687  arch = find_archetype(copy);
2688  if (!arch) {
2689  LOG(llevError, "Use: invalid archetype %s in %s.\n", copy, second->name);
2690  return 1;
2691  }
2692  add = object_create_arch(arch);
2693  add->nrof = count;
2694  object_insert_in_ob(add, op);
2695  } else if (strncmp(data, "remove $", 8) == 0) {
2696  data += 8;
2697  if (*data == '1') {
2698  if (first)
2699  first = object_decrease_nrof_by_one(first);
2700  data += 2;
2701  } else if (*data == '2') {
2702  if (second)
2703  second = object_decrease_nrof_by_one(second);
2704  data += 2;
2705  } else {
2706  LOG(llevError, "Use: invalid use string %s in %s\n", data, second->name);
2707  return 1;
2708  }
2709  } else {
2710  LOG(llevError, "Use: invalid use string %s in %s\n", data, second->name);
2711  return 1;
2712  }
2713  }
2714 
2715  return 1;
2716  */
2717 }
object_was_destroyed
#define object_was_destroyed(op, old_tag)
Definition: object.h:68
give.next
def next
Definition: give.py:44
obj::move_off
MoveType move_off
Definition: object.h:432
do_skill
int do_skill(object *op, object *part, object *skill, int dir, const char *string)
Definition: skill_util.c:422
get_weight_limit
uint32_t get_weight_limit(int stat)
Definition: living.c:2362
MIMIC
@ MIMIC
Definition: object.h:249
PLAYER
@ PLAYER
Definition: object.h:107
PU_BOOTS
#define PU_BOOTS
Definition: define.h:125
matcher_name
static int matcher_name(object *who, matcher_params *params, object *item)
Definition: c_object.c:774
global.h
castle_read.prefix
string prefix
Definition: castle_read.py:31
add_string
sstring add_string(const char *str)
Definition: shstr.c:124
object_remove
void object_remove(object *op)
Definition: object.c:1806
stringbuffer_new
StringBuffer * stringbuffer_new(void)
Definition: stringbuffer.c:57
NUM_BODY_LOCATIONS
#define NUM_BODY_LOCATIONS
Definition: object.h:13
MSG_TYPE_COMMAND_SUCCESS
#define MSG_TYPE_COMMAND_SUCCESS
Definition: newclient.h:530
AP_APPLY
#define AP_APPLY
Definition: define.h:574
BOW
@ BOW
Definition: object.h:118
BRACERS
@ BRACERS
Definition: object.h:217
CLOSE_CON
@ CLOSE_CON
Definition: object.h:229
llevError
@ llevError
Definition: logger.h:11
ARMOUR_IMPROVER
@ ARMOUR_IMPROVER
Definition: object.h:232
find_skill_by_number
object * find_skill_by_number(object *who, int skillno)
Definition: main.c:376
AP_NO_MERGE
#define AP_NO_MERGE
Definition: define.h:581
WAND
@ WAND
Definition: object.h:220
FLAG_UNDEAD
#define FLAG_UNDEAD
Definition: define.h:270
recipestruct::yield
int yield
Definition: recipe.h:21
SET_FLAG
#define SET_FLAG(xyz, p)
Definition: define.h:224
command_dropall
void command_dropall(object *op, const char *params)
Definition: c_object.c:1230
FLESH
@ FLESH
Definition: object.h:187
PU_NOT_CURSED
#define PU_NOT_CURSED
Definition: define.h:140
PU_ARROW
#define PU_ARROW
Definition: define.h:120
GLOVES
@ GLOVES
Definition: object.h:213
GIRDLE
@ GIRDLE
Definition: object.h:223
diamondslots.x
x
Definition: diamondslots.py:15
FLAG_STARTEQUIP
#define FLAG_STARTEQUIP
Definition: define.h:268
obj::count
tag_t count
Definition: object.h:300
obj::map
struct mapdef * map
Definition: object.h:298
MSG_TYPE_SKILL
#define MSG_TYPE_SKILL
Definition: newclient.h:407
QUERY_FLAG
#define QUERY_FLAG(xyz, p)
Definition: define.h:226
obj::race
sstring race
Definition: object.h:319
KEY
@ KEY
Definition: object.h:127
PU_INHIBIT
#define PU_INHIBIT
Definition: define.h:109
matcher_all
static int matcher_all(object *who, matcher_params *params, object *item)
Definition: c_object.c:740
find_recipe_for_tool
recipe * find_recipe_for_tool(const char *tool, recipe *from)
Definition: recipe.c:762
liv::Str
int8_t Str
Definition: living.h:36
FALSE
#define FALSE
Definition: compat.h:14
manor.params
params
Definition: manor.py:295
SK_DET_MAGIC
@ SK_DET_MAGIC
Definition: skills.h:30
UPD_WEIGHT
#define UPD_WEIGHT
Definition: newclient.h:316
liv::maxhp
int16_t maxhp
Definition: living.h:41
FOR_BELOW_PREPARE
#define FOR_BELOW_PREPARE(op_, it_)
Definition: define.h:702
GEM
@ GEM
Definition: object.h:167
pl
Definition: player.h:92
detect_curse_on_item
int detect_curse_on_item(object *pl, object *tmp, object *skill)
Definition: skills.c:701
shop_price_buy
uint64_t shop_price_buy(const object *obj, object *who)
Definition: shop.c:186
pickup_modes
static const uint32_t pickup_modes[]
Definition: c_object.c:43
get_pickup_mode_index
static int get_pickup_mode_index(const char *name)
Definition: c_object.c:58
ARMOUR
@ ARMOUR
Definition: object.h:120
SK_DISARM_TRAPS
@ SK_DISARM_TRAPS
Definition: skills.h:46
PU_FOOD
#define PU_FOOD
Definition: define.h:115
WEAPON
@ WEAPON
Definition: object.h:119
typedata::identifyskill
int identifyskill
Definition: define.h:93
object_matches_string
int object_matches_string(object *pl, object *op, const char *name)
Definition: object.c:4564
esrv_send_pickup
void esrv_send_pickup(player *pl)
Definition: request.c:1740
PU_BOW
#define PU_BOW
Definition: define.h:118
liv::hp
int16_t hp
Definition: living.h:40
pick_up
void pick_up(object *op, object *alt)
Definition: c_object.c:519
PU_MAGIC_DEVICE
#define PU_MAGIC_DEVICE
Definition: define.h:138
set_pickup_mode
static void set_pickup_mode(const object *op, int i)
Definition: c_object.c:2275
commongive.inv
inv
Definition: commongive.py:28
AMULET
@ AMULET
Definition: object.h:139
MIN
#define MIN(x, y)
Definition: compat.h:21
SKILL
@ SKILL
Definition: object.h:143
command_disarm
void command_disarm(object *op, const char *params)
Definition: c_object.c:224
change_skill
int change_skill(object *who, object *new_skill, int flag)
Definition: skill_util.c:350
MSG_TYPE_COMMAND_EXAMINE
#define MSG_TYPE_COMMAND_EXAMINE
Definition: newclient.h:532
Ice.tmp
int tmp
Definition: Ice.py:207
PU_MISSILEWEAPON
#define PU_MISSILEWEAPON
Definition: define.h:130
object_matches_pickup_mode
int object_matches_pickup_mode(const object *item, int mode)
Definition: c_object.c:656
TRANSPORT
@ TRANSPORT
Definition: object.h:108
command_take
void command_take(object *op, const char *params)
Definition: c_object.c:845
PU_FLESH
#define PU_FLESH
Definition: define.h:142
command_drop
void command_drop(object *op, const char *params)
Definition: c_object.c:1354
obj::msg
sstring msg
Definition: object.h:323
empty_container
static void empty_container(object *container, object *pl)
Definition: c_object.c:1412
PU_READABLES
#define PU_READABLES
Definition: define.h:137
skills.h
PU_POTION
#define PU_POTION
Definition: define.h:133
MSG_TYPE_COMMAND_ERROR
#define MSG_TYPE_COMMAND_ERROR
Definition: newclient.h:529
recipestruct::ingred_count
int ingred_count
Definition: recipe.h:23
command_empty
void command_empty(object *op, const char *params)
Definition: c_object.c:1450
matcher_params::item_to_pick
int item_to_pick
Definition: c_object.c:714
FLAG_PROBE
#define FLAG_PROBE
Definition: define.h:257
FLAG_INV_LOCKED
#define FLAG_INV_LOCKED
Definition: define.h:329
MSG_TYPE_SPELL_INFO
#define MSG_TYPE_SPELL_INFO
Definition: newclient.h:639
apply_by_living_below
void apply_by_living_below(object *pl)
Definition: apply.c:695
FLAG_APPLIED
#define FLAG_APPLIED
Definition: define.h:235
NDI_BLUE
#define NDI_BLUE
Definition: newclient.h:247
events_execute_object_event
int events_execute_object_event(object *op, int eventcode, object *activator, object *third, const char *message, int fix)
Definition: events.cpp:259
put_object_in_sack
void put_object_in_sack(object *op, object *sack, object *tmp, uint32_t nrof)
Definition: c_object.c:937
item_matcher
int(* item_matcher)(object *who, matcher_params *params, object *item)
Definition: c_object.c:731
HUGE_BUF
#define HUGE_BUF
Definition: define.h:37
sack_can_hold
int sack_can_hold(const object *pl, const object *sack, const object *op, uint32_t nrof)
Definition: c_object.c:317
POISONING
@ POISONING
Definition: object.h:218
MSG_TYPE_COMMAND
#define MSG_TYPE_COMMAND
Definition: newclient.h:404
inventory
void inventory(object *op, object *inv)
Definition: c_object.c:2016
body_locations_struct::nonuse_name
const char * nonuse_name
Definition: object.h:23
obj::nrof
uint32_t nrof
Definition: object.h:335
FLAG_NO_PICK
#define FLAG_NO_PICK
Definition: define.h:239
command_examine
void command_examine(object *op, const char *params)
Definition: c_object.c:1489
FOR_BELOW_FINISH
#define FOR_BELOW_FINISH()
Definition: define.h:709
archt
Definition: object.h:468
settings
struct Settings settings
Definition: init.c:39
object_merge
object * object_merge(object *op, object *top)
Definition: object.c:2018
obj::slaying
sstring slaying
Definition: object.h:320
LOOK_OBJ
#define LOOK_OBJ(ob)
Definition: object.h:508
AP_NULL
#define AP_NULL
Definition: define.h:573
free_string
void free_string(sstring str)
Definition: shstr.c:280
PU_GLOVES
#define PU_GLOVES
Definition: define.h:126
typedata
Definition: define.h:89
PU_CONTAINER
#define PU_CONTAINER
Definition: define.h:143
recipestruct
Definition: recipe.h:10
autojail.who
who
Definition: autojail.py:3
CLOAK
@ CLOAK
Definition: object.h:204
command_lock_item
void command_lock_item(object *op, const char *params)
Definition: c_object.c:2558
NROF
static uint32_t NROF(const object *const ob)
Definition: object.h:612
matcher_params::name
char name[100]
Definition: c_object.c:718
HELMET
@ HELMET
Definition: object.h:136
use_skill
int use_skill(object *op, const char *string)
Definition: skill_util.c:955
stringbuffer_trim_whitespace
void stringbuffer_trim_whitespace(StringBuffer *sb)
Definition: stringbuffer.c:188
disinfect.map
map
Definition: disinfect.py:4
object_decrease_nrof_by_one
#define object_decrease_nrof_by_one(xyz)
Definition: compat.h:32
POISON
@ POISON
Definition: object.h:113
PU_RATIO
#define PU_RATIO
Definition: define.h:113
display_new_pickup
static void display_new_pickup(const object *op, int old)
Definition: c_object.c:2081
FLAG_WAS_WIZ
#define FLAG_WAS_WIZ
Definition: define.h:234
obj::name
sstring name
Definition: object.h:312
linked_char::name
const char * name
Definition: global.h:87
PU_KEY
#define PU_KEY
Definition: define.h:128
is_identifiable_type
int is_identifiable_type(const object *op)
Definition: item.c:1311
command_mark
void command_mark(object *op, const char *params)
Definition: c_object.c:1567
EVENT_PICKUP
#define EVENT_PICKUP
Definition: events.h:27
matcher_params::pickup_type
int pickup_type
Definition: c_object.c:719
query_name
void query_name(const object *op, char *buf, size_t size)
Definition: item.c:584
mon
object * mon
Definition: comet_perf.c:75
POTION
@ POTION
Definition: object.h:111
body_locations_struct::use_name
const char * use_name
Definition: object.h:22
FLAG_KNOWN_CURSED
#define FLAG_KNOWN_CURSED
Definition: define.h:320
EVENT_DROP
#define EVENT_DROP
Definition: events.h:26
SK_DET_CURSE
@ SK_DET_CURSE
Definition: skills.h:33
pickup_names
static const char * pickup_names[]
Definition: c_object.c:33
set_object_face_main
int set_object_face_main(object *op)
Definition: apply.c:146
MSG_TYPE_COMMAND_INFO
#define MSG_TYPE_COMMAND_INFO
Definition: newclient.h:526
FOR_OB_AND_BELOW_FINISH
#define FOR_OB_AND_BELOW_FINISH()
Definition: define.h:752
HEAD
#define HEAD(op)
Definition: object.h:594
stringbuffer_append_string
void stringbuffer_append_string(StringBuffer *sb, const char *str)
Definition: stringbuffer.c:95
transport_can_hold
int transport_can_hold(const object *transport, const object *op, int nrof)
Definition: apply.c:54
ROD
@ ROD
Definition: object.h:109
object_can_pick
int object_can_pick(const object *who, const object *item)
Definition: object.c:3875
recipestruct::arch_name
char ** arch_name
Definition: recipe.h:13
CONTAINER
@ CONTAINER
Definition: object.h:231
PU_STOP
#define PU_STOP
Definition: define.h:110
PU_VALUABLES
#define PU_VALUABLES
Definition: define.h:117
FLAG_FREED
#define FLAG_FREED
Definition: define.h:233
SCRIPT_FIX_ALL
#define SCRIPT_FIX_ALL
Definition: global.h:367
query_short_name
void query_short_name(const object *op, char *buf, size_t size)
Definition: item.c:509
object_present_in_ob
object * object_present_in_ob(uint8_t type, const object *op)
Definition: object.c:3118
SPECIAL_KEY
@ SPECIAL_KEY
Definition: object.h:124
MOVE_FLYING
#define MOVE_FLYING
Definition: define.h:395
obj::carrying
int32_t carrying
Definition: object.h:370
FREE_AND_COPY
#define FREE_AND_COPY(sv, nv)
Definition: global.h:202
obj::x
int16_t x
Definition: object.h:328
INS_NO_MERGE
#define INS_NO_MERGE
Definition: object.h:567
SKILLSCROLL
@ SKILLSCROLL
Definition: object.h:234
fix_object
void fix_object(object *op)
Definition: living.c:1126
UPD_FLAGS
#define UPD_FLAGS
Definition: newclient.h:315
CFweardisguise.tag
tag
Definition: CFweardisguise.py:25
stringbuffer_finish
char * stringbuffer_finish(StringBuffer *sb)
Definition: stringbuffer.c:76
FOR_INV_FINISH
#define FOR_INV_FINISH()
Definition: define.h:675
identify_object_with_skill
int identify_object_with_skill(object *tmp, object *pl, object *skill, int print_on_success)
Definition: skills.c:808
INS_BELOW_ORIGINATOR
#define INS_BELOW_ORIGINATOR
Definition: object.h:571
MSG_TYPE_SKILL_MISSING
#define MSG_TYPE_SKILL_MISSING
Definition: newclient.h:587
PU_SPELLBOOK
#define PU_SPELLBOOK
Definition: define.h:135
disinfect.count
int count
Definition: disinfect.py:7
matcher_params
Definition: c_object.c:711
do_skill_by_number
static void do_skill_by_number(object *op, int skill_subtype, const char *params, const char *missing_message)
Definition: c_object.c:188
knowledge_item_can_be_used_alchemy
void knowledge_item_can_be_used_alchemy(object *op, const object *item)
Definition: knowledge.c:1328
tag_t
uint32_t tag_t
Definition: object.h:12
obj::env
struct obj * env
Definition: object.h:294
PU_MELEEWEAPON
#define PU_MELEEWEAPON
Definition: define.h:131
sproto.h
liv::food
int32_t food
Definition: living.h:48
ARROW
@ ARROW
Definition: object.h:117
FLAG_NO_DROP
#define FLAG_NO_DROP
Definition: define.h:288
command_pickup
void command_pickup(object *op, const char *params)
Definition: c_object.c:2210
PU_MAGICAL
#define PU_MAGICAL
Definition: define.h:132
FOR_OB_AND_BELOW_PREPARE
#define FOR_OB_AND_BELOW_PREPARE(op_)
Definition: define.h:748
mapdef
Definition: map.h:324
MSG_TYPE_SPELL
#define MSG_TYPE_SPELL
Definition: newclient.h:411
BOOK
@ BOOK
Definition: object.h:114
RING
@ RING
Definition: object.h:185
detect_magic_on_item
int detect_magic_on_item(object *pl, object *tmp, object *skill)
Definition: skills.c:750
PU_HELMET
#define PU_HELMET
Definition: define.h:121
nlohmann::detail::void
j template void())
Definition: json.hpp:4099
FLAG_MONSTER
#define FLAG_MONSTER
Definition: define.h:245
recipestruct::ingred
linked_char * ingred
Definition: recipe.h:22
find_skill_by_name
object * find_skill_by_name(object *who, const char *name)
Definition: skill_util.c:202
strlcpy
size_t strlcpy(char *dst, const char *src, size_t size)
Definition: porting.c:220
env
static std::shared_ptr< inja::Environment > env
Definition: mapper.cpp:2215
matcher_pickup_type
static int matcher_pickup_type(object *who, matcher_params *params, object *item)
Definition: c_object.c:794
drop_object
object * drop_object(object *op, object *tmp, uint32_t nrof)
Definition: c_object.c:1073
MAX_BUF
#define MAX_BUF
Definition: define.h:35
create_archetype
object * create_archetype(const char *name)
Definition: arch.cpp:281
command_search
void command_search(object *op, const char *params)
Definition: c_object.c:212
IS_PLAYER
static bool IS_PLAYER(object *op)
Definition: object.h:596
StringBuffer
Definition: stringbuffer.c:25
matcher_params::item_must_be_pickable
int item_must_be_pickable
Definition: c_object.c:716
FREE_AND_CLEAR_STR
#define FREE_AND_CLEAR_STR(xyz)
Definition: global.h:196
probe
int probe(object *op, object *caster, object *spell_ob, int dir, int level)
Definition: spell_effect.c:707
is_valid_types_gen.found
found
Definition: is_valid_types_gen.py:39
MSG_TYPE_COMMAND_FAILURE
#define MSG_TYPE_COMMAND_FAILURE
Definition: newclient.h:531
EXIT
@ EXIT
Definition: object.h:181
obj::y
int16_t y
Definition: object.h:328
FLAG_KNOWN_MAGICAL
#define FLAG_KNOWN_MAGICAL
Definition: define.h:319
obj::arch
struct archt * arch
Definition: object.h:416
ob_describe
char * ob_describe(const object *op, const object *observer, int use_media_tags, char *buf, size_t size)
Definition: ob_methods.c:91
make_matcher
static item_matcher make_matcher(object *who, const char *params, matcher_params *mp)
Definition: c_object.c:806
FLAG_REMOVED
#define FLAG_REMOVED
Definition: define.h:232
MSG_TYPE_COMMAND_INVENTORY
#define MSG_TYPE_COMMAND_INVENTORY
Definition: newclient.h:533
FLAG_WIZ
#define FLAG_WIZ
Definition: define.h:231
obj::type
uint8_t type
Definition: object.h:341
NDI_UNIQUE
#define NDI_UNIQUE
Definition: newclient.h:262
obj::stats
living stats
Definition: object.h:371
PU_CLOAK
#define PU_CLOAK
Definition: define.h:127
drop
void drop(object *op, object *tmp)
Definition: c_object.c:1168
AP_OPEN
#define AP_OPEN
Definition: define.h:576
archt::clone
object clone
Definition: object.h:472
cost_approx_str
char * cost_approx_str(const object *obj, object *who)
Definition: shop.c:409
pick_up_object
static void pick_up_object(object *pl, object *op, object *tmp, int nrof)
Definition: c_object.c:379
PU_JEWELS
#define PU_JEWELS
Definition: define.h:141
item
Definition: item.py:1
cost_str
char * cost_str(uint64_t cost)
Definition: shop.c:405
FLAG_IS_BUILDABLE
#define FLAG_IS_BUILDABLE
Definition: define.h:367
LOG
void LOG(LogLevel logLevel, const char *format,...)
Definition: logger.c:51
command_throw
void command_throw(object *op, const char *params)
Definition: c_object.c:239
command_uskill
void command_uskill(object *pl, const char *params)
Definition: c_object.c:144
query_weight
void query_weight(const object *op, char *buf, size_t size)
Definition: item.c:411
get_button_value
int get_button_value(const object *button)
Definition: button.c:749
give.op
op
Definition: give.py:33
autojail.value
value
Definition: autojail.py:6
object_insert_in_map
object * object_insert_in_map(object *op, mapstruct *m, object *originator, int flag)
Definition: object.c:2328
shop.h
PU_ARMOUR
#define PU_ARMOUR
Definition: define.h:123
apply_by_living
int apply_by_living(object *pl, object *op, int aflag, int quiet)
Definition: apply.c:637
esrv_update_item
void esrv_update_item(int flags, object *pl, object *op)
Definition: main.c:360
query_base_name
void query_base_name(const object *op, int plural, char *buf, size_t size)
Definition: item.c:685
Settings::max_stat
uint8_t max_stat
Definition: global.h:320
PU_NEWMODE
#define PU_NEWMODE
Definition: define.h:111
SKILL_TOOL
@ SKILL_TOOL
Definition: object.h:189
FLAG_NO_FIX_PLAYER
#define FLAG_NO_FIX_PLAYER
Definition: define.h:277
diamondslots.y
y
Definition: diamondslots.py:16
CLEAR_FLAG
#define CLEAR_FLAG(xyz, p)
Definition: define.h:225
npc_dialog.index
int index
Definition: npc_dialog.py:102
knowledge_show_monster_detail
void knowledge_show_monster_detail(object *op, const char *name)
Definition: knowledge.c:1522
SK_SUBTRACT_SKILL_EXP
#define SK_SUBTRACT_SKILL_EXP
Definition: skills.h:81
apply_special
int apply_special(object *who, object *op, int aflags)
Definition: apply.c:1156
buf
StringBuffer * buf
Definition: readable.c:1606
change_exp
void change_exp(object *op, int64_t exp, const char *skill_name, int flag)
Definition: living.c:2168
object_insert_in_ob
object * object_insert_in_ob(object *op, object *where)
Definition: object.c:2820
get_typedata
const typedata * get_typedata(int itemtype)
Definition: item.c:319
obj::weight_limit
int32_t weight_limit
Definition: object.h:369
command_use
void command_use(object *op, const char *params)
Definition: c_object.c:2601
typedata::identifyskill2
int identifyskill2
Definition: define.h:94
CORPSE
@ CORPSE
Definition: object.h:243
make_face_from_files.int
int
Definition: make_face_from_files.py:26
command_rskill
void command_rskill(object *pl, const char *params)
Definition: c_object.c:161
UPD_NAME
#define UPD_NAME
Definition: newclient.h:318
obj::skill
sstring skill
Definition: object.h:322
AT_ACID
#define AT_ACID
Definition: attack.h:82
loader.h
save_player
int save_player(object *op, int flag)
Definition: login.c:230
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.c:2067
Settings::real_wiz
uint8_t real_wiz
Definition: global.h:267
draw_ext_info
void draw_ext_info(int flags, int pri, const object *pl, uint8_t type, uint8_t subtype, const char *message)
Definition: main.c:309
stop_item
object * stop_item(object *op)
Definition: time.c:447
object_free_drop_inventory
void object_free_drop_inventory(object *ob)
Definition: object.c:1533
FOOD
@ FOOD
Definition: object.h:112
command_rename_item
void command_rename_item(object *op, const char *params)
Definition: c_object.c:2373
find_marked_object
object * find_marked_object(object *op)
Definition: c_object.c:1520
FLAG_UNPAID
#define FLAG_UNPAID
Definition: define.h:236
matcher_number
static int matcher_number(object *who, matcher_params *params, object *item)
Definition: c_object.c:754
level
int level
Definition: readable.c:1604
DRINK
@ DRINK
Definition: object.h:157
sell_item
void sell_item(object *op, object *pl)
Definition: shop.c:963
VERY_BIG_BUF
#define VERY_BIG_BUF
Definition: define.h:36
archt::name
sstring name
Definition: object.h:469
examine_monster
void examine_monster(object *op, object *tmp, int level)
Definition: c_object.c:1614
PU_CURSED
#define PU_CURSED
Definition: define.h:144
WEAPON_IMPROVER
@ WEAPON_IMPROVER
Definition: object.h:233
SCROLL
@ SCROLL
Definition: object.h:221
FLAG_IS_LINKED
#define FLAG_IS_LINKED
Definition: define.h:315
object_find_by_type_and_name
object * object_find_by_type_and_name(const object *who, int type, const char *name)
Definition: object.c:4116
say.item
dictionary item
Definition: say.py:149
matcher_params::missed
int missed
Definition: c_object.c:721
Settings::search_items
uint8_t search_items
Definition: global.h:263
command_apply
void command_apply(object *op, const char *params)
Definition: c_object.c:251
AP_UNAPPLY
#define AP_UNAPPLY
Definition: define.h:575
obj::attacktype
uint32_t attacktype
Definition: object.h:345
SK_FIND_TRAPS
@ SK_FIND_TRAPS
Definition: skills.h:34
find_best_object_match
static object * find_best_object_match(object *pl, const char *params)
Definition: c_object.c:132
PU_DRINK
#define PU_DRINK
Definition: define.h:116
BOOTS
@ BOOTS
Definition: object.h:212
find_best_apply_object_match
static object * find_best_apply_object_match(object *start, object *pl, const char *params, int aflag)
Definition: c_object.c:101
shop_contains
bool shop_contains(object *ob)
Definition: shop.c:1287
examine
void examine(object *op, object *tmp)
Definition: c_object.c:1702
FLAG_IS_CAULDRON
#define FLAG_IS_CAULDRON
Definition: define.h:338
matcher_params::item_number
int item_number
Definition: c_object.c:715
command_search_items
void command_search_items(object *op, const char *params)
Definition: c_object.c:2328
object_get_player_container
object * object_get_player_container(object *op)
Definition: object.c:600
PU_SHIELD
#define PU_SHIELD
Definition: define.h:122
SHIELD
@ SHIELD
Definition: object.h:135
FLAG_NO_SKILL_IDENT
#define FLAG_NO_SKILL_IDENT
Definition: define.h:335
body_locations
body_locations_struct body_locations[NUM_BODY_LOCATIONS]
Definition: item.c:54
living.h
FLAG_IS_THROWN
#define FLAG_IS_THROWN
Definition: define.h:249
object_split
object * object_split(object *orig_ob, uint32_t nr, char *err, size_t size)
Definition: object.c:2600
SK_THROWING
@ SK_THROWING
Definition: skills.h:44
SPELLBOOK
@ SPELLBOOK
Definition: object.h:203
shop_price_sell
uint64_t shop_price_sell(const object *obj, object *who)
Definition: shop.c:238
FOR_INV_PREPARE
#define FOR_INV_PREPARE(op_, it_)
Definition: define.h:668
FORCE
@ FORCE
Definition: object.h:224
draw_ext_info_format
void draw_ext_info_format(int flags, int pri, const object *pl, uint8_t type, uint8_t subtype, const char *format,...)
Definition: main.c:319
obj::level
int16_t level
Definition: object.h:354
llevDebug
@ llevDebug
Definition: logger.h:13
MONEY
@ MONEY
Definition: object.h:137
FLAG_IS_FLOOR
#define FLAG_IS_FLOOR
Definition: define.h:302
FORCE_NAME
#define FORCE_NAME
Definition: spells.h:169
obj::inv
struct obj * inv
Definition: object.h:291
FLAG_IDENTIFIED
#define FLAG_IDENTIFIED
Definition: define.h:261
give.name
name
Definition: give.py:27
PU_DEBUG
#define PU_DEBUG
Definition: define.h:108
get_archetype_by_skill_name
archetype * get_archetype_by_skill_name(const char *skill, int type)
Definition: arch.cpp:82
PU_SKILLSCROLL
#define PU_SKILLSCROLL
Definition: define.h:136
is_identified
int is_identified(const object *op)
Definition: item.c:1335
level
Definition: level.py:1