1 | /* |
1 | /* |
2 | * This file is part of Crossfire TRT, the Roguelike Realtime MORPG. |
2 | * This file is part of Deliantra, the Roguelike Realtime MMORPG. |
3 | * |
3 | * |
4 | * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team |
4 | * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team |
5 | * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team |
5 | * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team |
6 | * Copyright (©) 1992,2007 Frank Tore Johansen |
6 | * Copyright (©) 1992,2007 Frank Tore Johansen |
7 | * |
7 | * |
8 | * Crossfire TRT is free software: you can redistribute it and/or modify |
8 | * Deliantra is free software: you can redistribute it and/or modify |
9 | * it under the terms of the GNU General Public License as published by |
9 | * it under the terms of the GNU General Public License as published by |
10 | * the Free Software Foundation, either version 3 of the License, or |
10 | * the Free Software Foundation, either version 3 of the License, or |
11 | * (at your option) any later version. |
11 | * (at your option) any later version. |
12 | * |
12 | * |
13 | * This program is distributed in the hope that it will be useful, |
13 | * This program is distributed in the hope that it will be useful, |
… | |
… | |
16 | * GNU General Public License for more details. |
16 | * GNU General Public License for more details. |
17 | * |
17 | * |
18 | * You should have received a copy of the GNU General Public License |
18 | * You should have received a copy of the GNU General Public License |
19 | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
19 | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
20 | * |
20 | * |
21 | * The authors can be reached via e-mail to <crossfire@schmorp.de> |
21 | * The authors can be reached via e-mail to <support@deliantra.net> |
22 | */ |
22 | */ |
23 | |
23 | |
24 | #include <cmath> |
24 | #include <cmath> |
25 | |
25 | |
26 | #include <global.h> |
26 | #include <global.h> |
… | |
… | |
113 | { |
113 | { |
114 | if (operate_altar (altar, &money)) |
114 | if (operate_altar (altar, &money)) |
115 | { |
115 | { |
116 | identify (marked); |
116 | identify (marked); |
117 | |
117 | |
118 | buf.printf ("You have %s.", long_desc (marked, pl)); |
118 | buf.printf ("You have %s.\n\n", long_desc (marked, pl)); |
119 | if (marked->msg) |
119 | if (marked->msg) |
120 | buf << "The item has a story:\n" << marked->msg; |
120 | buf << "The item has a story:\n\n" << marked->msg << "\n\n"; |
121 | |
121 | |
122 | return !money; |
122 | return !money; |
123 | } |
123 | } |
124 | } |
124 | } |
125 | |
125 | |
… | |
… | |
129 | { |
129 | { |
130 | if (operate_altar (altar, &money)) |
130 | if (operate_altar (altar, &money)) |
131 | { |
131 | { |
132 | identify (id); |
132 | identify (id); |
133 | |
133 | |
134 | buf.printf ("You have %s.", long_desc (id, pl)); |
134 | buf.printf ("You have %s.\n\n", long_desc (id, pl)); |
135 | if (id->msg) |
135 | if (id->msg) |
136 | buf << "The item has a story:\n" << id->msg; |
136 | buf << "The item has a story:\n\n" << id->msg << "\n\n"; |
137 | |
137 | |
138 | /* If no more money, might as well quit now */ |
138 | /* If no more money, might as well quit now */ |
139 | if (!money || !check_altar_sacrifice (altar, money)) |
139 | if (!money || !check_altar_sacrifice (altar, money)) |
140 | break; |
140 | break; |
141 | } |
141 | } |
… | |
… | |
146 | } |
146 | } |
147 | } |
147 | } |
148 | } |
148 | } |
149 | |
149 | |
150 | if (buf.empty ()) |
150 | if (buf.empty ()) |
151 | buf << ("You have nothing that needs identifying"); |
151 | pl->failmsg ("You have nothing that needs identifying"); |
152 | |
152 | else |
153 | pl->contr->infobox ("Identify", buf); |
153 | pl->contr->infobox (MSG_CHANNEL ("identify"), buf); |
154 | |
154 | |
155 | return !money; |
155 | return !money; |
156 | } |
156 | } |
157 | |
157 | |
158 | /** |
158 | /** |
… | |
… | |
217 | |
217 | |
218 | if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)) |
218 | if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)) |
219 | { |
219 | { |
220 | op->drain_stat (); |
220 | op->drain_stat (); |
221 | op->update_stats (); |
221 | op->update_stats (); |
222 | decrease_ob (tmp); |
222 | tmp->decrease (); |
223 | return 1; |
223 | return 1; |
224 | } |
224 | } |
225 | |
225 | |
226 | if (!(at = archetype::find (ARCH_DEPLETION))) |
226 | if (!(at = archetype::find (ARCH_DEPLETION))) |
227 | { |
227 | { |
228 | LOG (llevError, "Could not find archetype depletion\n"); |
228 | LOG (llevError, "Could not find archetype depletion\n"); |
229 | return 0; |
229 | return 0; |
230 | } |
230 | } |
|
|
231 | |
231 | depl = present_arch_in_ob (at, op); |
232 | depl = present_arch_in_ob (at, op); |
232 | |
233 | |
233 | if (depl) |
234 | if (depl) |
234 | { |
235 | { |
235 | for (i = 0; i < NUM_STATS; i++) |
236 | for (i = 0; i < NUM_STATS; i++) |
… | |
… | |
240 | op->update_stats (); |
241 | op->update_stats (); |
241 | } |
242 | } |
242 | else |
243 | else |
243 | op->statusmsg ("Your potion had no effect."); |
244 | op->statusmsg ("Your potion had no effect."); |
244 | |
245 | |
245 | decrease_ob (tmp); |
246 | tmp->decrease (); |
246 | return 1; |
247 | return 1; |
247 | } |
248 | } |
248 | |
249 | |
249 | /* improvement potion - only for players */ |
250 | /* improvement potion - only for players */ |
250 | if (op->type == PLAYER && (tmp->attacktype & AT_GODPOWER)) |
251 | if (op->type == PLAYER && (tmp->attacktype & AT_GODPOWER)) |
… | |
… | |
318 | } |
319 | } |
319 | else |
320 | else |
320 | op->statusmsg ("You are fortunate that you are so pathetic.", NDI_DK_ORANGE); |
321 | op->statusmsg ("You are fortunate that you are so pathetic.", NDI_DK_ORANGE); |
321 | } |
322 | } |
322 | |
323 | |
323 | decrease_ob (tmp); |
324 | tmp->decrease (); |
324 | return 1; |
325 | return 1; |
325 | } |
326 | } |
326 | |
327 | |
327 | |
328 | |
328 | /* A potion that casts a spell. Healing, restore spellpoint (power potion) |
329 | /* A potion that casts a spell. Healing, restore spellpoint (power potion) |
… | |
… | |
347 | insert_ob_in_map (fball, op->map, NULL, 0); |
348 | insert_ob_in_map (fball, op->map, NULL, 0); |
348 | } |
349 | } |
349 | else |
350 | else |
350 | cast_spell (op, tmp, op->facing, tmp->inv, NULL); |
351 | cast_spell (op, tmp, op->facing, tmp->inv, NULL); |
351 | |
352 | |
352 | decrease_ob (tmp); |
353 | tmp->decrease (); |
353 | |
354 | |
354 | /* if youre dead, no point in doing this... */ |
355 | /* if youre dead, no point in doing this... */ |
355 | if (!QUERY_FLAG (op, FLAG_REMOVED)) |
356 | if (!QUERY_FLAG (op, FLAG_REMOVED)) |
356 | op->update_stats (); |
357 | op->update_stats (); |
357 | |
358 | |
… | |
… | |
388 | force->speed_left = -1; |
389 | force->speed_left = -1; |
389 | force = insert_ob_in_ob (force, op); |
390 | force = insert_ob_in_ob (force, op); |
390 | CLEAR_FLAG (tmp, FLAG_APPLIED); |
391 | CLEAR_FLAG (tmp, FLAG_APPLIED); |
391 | SET_FLAG (force, FLAG_APPLIED); |
392 | SET_FLAG (force, FLAG_APPLIED); |
392 | change_abil (op, force); |
393 | change_abil (op, force); |
393 | decrease_ob (tmp); |
394 | tmp->decrease (); |
394 | return 1; |
395 | return 1; |
395 | } |
396 | } |
396 | |
397 | |
397 | /* Only thing left are the stat potions */ |
398 | /* Only thing left are the stat potions */ |
398 | if (op->type == PLAYER) |
399 | if (op->type == PLAYER) |
… | |
… | |
411 | * stat will not be raised by them. fix_player just clears |
412 | * stat will not be raised by them. fix_player just clears |
412 | * up all the stats. |
413 | * up all the stats. |
413 | */ |
414 | */ |
414 | CLEAR_FLAG (tmp, FLAG_APPLIED); |
415 | CLEAR_FLAG (tmp, FLAG_APPLIED); |
415 | op->update_stats (); |
416 | op->update_stats (); |
416 | decrease_ob (tmp); |
417 | tmp->decrease (); |
417 | return 1; |
418 | return 1; |
418 | } |
419 | } |
419 | |
420 | |
420 | /**************************************************************************** |
421 | /**************************************************************************** |
421 | * Weapon improvement code follows |
422 | * Weapon improvement code follows |
… | |
… | |
468 | { |
469 | { |
469 | if (strcmp (op->arch->archname, item) == 0) |
470 | if (strcmp (op->arch->archname, item) == 0) |
470 | { |
471 | { |
471 | if (op->nrof >= nrof) |
472 | if (op->nrof >= nrof) |
472 | { |
473 | { |
473 | decrease_ob_nr (op, nrof); |
474 | op->decrease (nrof); |
474 | return; |
475 | return; |
475 | } |
476 | } |
476 | else |
477 | else |
477 | { |
478 | { |
478 | decrease_ob_nr (op, op->nrof); |
479 | op->decrease (nrof); |
479 | nrof -= op->nrof; |
480 | nrof -= op->nrof; |
480 | } |
481 | } |
481 | |
482 | |
482 | op = prev; |
483 | op = prev; |
483 | } |
484 | } |
… | |
… | |
568 | static int |
569 | static int |
569 | improve_weapon_stat (object *op, object *improver, object *weapon, sint8 &stat, int sacrifice_count, const char *statname) |
570 | improve_weapon_stat (object *op, object *improver, object *weapon, sint8 &stat, int sacrifice_count, const char *statname) |
570 | { |
571 | { |
571 | stat += sacrifice_count; |
572 | stat += sacrifice_count; |
572 | weapon->last_eat++; |
573 | weapon->last_eat++; |
573 | decrease_ob (improver); |
574 | improver->decrease (); |
574 | |
575 | |
575 | /* So it updates the players stats and the window */ |
576 | /* So it updates the players stats and the window */ |
576 | op->update_stats (); |
577 | op->update_stats (); |
577 | |
578 | |
578 | op->statusmsg (format ( |
579 | op->statusmsg (format ( |
… | |
… | |
623 | if (i < NROFATTACKS || weapon->stats.hp || /* regeneration */ |
624 | if (i < NROFATTACKS || weapon->stats.hp || /* regeneration */ |
624 | (weapon->stats.sp && weapon->type == WEAPON) || /* sp regeneration */ |
625 | (weapon->stats.sp && weapon->type == WEAPON) || /* sp regeneration */ |
625 | weapon->stats.exp || /* speed */ |
626 | weapon->stats.exp || /* speed */ |
626 | weapon->stats.ac) /* AC - only taifu's I think */ |
627 | weapon->stats.ac) /* AC - only taifu's I think */ |
627 | { |
628 | { |
628 | op->failmsg ("You cannot prepare magic weapons."); |
629 | op->failmsg ("You cannot prepare magic weapons. " |
|
|
630 | "H<A weapon is considered magical if it changes regeneration, " |
|
|
631 | "speed or ac.>"); |
629 | return 0; |
632 | return 0; |
630 | } |
633 | } |
631 | |
634 | |
632 | sacrifice_count = check_sacrifice (op, improver); |
635 | sacrifice_count = check_sacrifice (op, improver); |
633 | if (sacrifice_count <= 0) |
636 | if (sacrifice_count <= 0) |
… | |
… | |
644 | |
647 | |
645 | sprintf (buf, "%s's %s", &op->name, &weapon->name); |
648 | sprintf (buf, "%s's %s", &op->name, &weapon->name); |
646 | weapon->name = weapon->name_pl = buf; |
649 | weapon->name = weapon->name_pl = buf; |
647 | weapon->nrof = 0; /* prevents preparing n weapons in the same |
650 | weapon->nrof = 0; /* prevents preparing n weapons in the same |
648 | slot at once! */ |
651 | slot at once! */ |
649 | decrease_ob (improver); |
652 | improver->decrease (); |
650 | weapon->last_eat = 0; |
653 | weapon->last_eat = 0; |
651 | return 1; |
654 | return 1; |
652 | } |
655 | } |
653 | |
656 | |
654 | |
657 | |
… | |
… | |
702 | weapon->weight += 5000; /* 5 KG's */ |
705 | weapon->weight += 5000; /* 5 KG's */ |
703 | op->statusmsg (format ("Damage has been increased by 5 to %d.", weapon->stats.dam)); |
706 | op->statusmsg (format ("Damage has been increased by 5 to %d.", weapon->stats.dam)); |
704 | weapon->last_eat++; |
707 | weapon->last_eat++; |
705 | |
708 | |
706 | weapon->item_power++; |
709 | weapon->item_power++; |
707 | decrease_ob (improver); |
710 | improver->decrease (); |
708 | return 1; |
711 | return 1; |
709 | } |
712 | } |
710 | |
713 | |
711 | if (improver->stats.sp == IMPROVE_WEIGHT) |
714 | if (improver->stats.sp == IMPROVE_WEIGHT) |
712 | { |
715 | { |
… | |
… | |
716 | weapon->weight = 1; |
719 | weapon->weight = 1; |
717 | |
720 | |
718 | op->statusmsg (format ("Weapon weight reduced to %6.1fkg.", (float) weapon->weight / 1000.0)); |
721 | op->statusmsg (format ("Weapon weight reduced to %6.1fkg.", (float) weapon->weight / 1000.0)); |
719 | weapon->last_eat++; |
722 | weapon->last_eat++; |
720 | weapon->item_power++; |
723 | weapon->item_power++; |
721 | decrease_ob (improver); |
724 | improver->decrease (); |
722 | return 1; |
725 | return 1; |
723 | } |
726 | } |
724 | if (improver->stats.sp == IMPROVE_ENCHANT) |
727 | if (improver->stats.sp == IMPROVE_ENCHANT) |
725 | { |
728 | { |
726 | weapon->magic++; |
729 | weapon->magic++; |
727 | weapon->last_eat++; |
730 | weapon->last_eat++; |
728 | op->statusmsg (format ("Weapon magic increased to %d.", weapon->magic)); |
731 | op->statusmsg (format ("Weapon magic increased to %d.", weapon->magic)); |
729 | decrease_ob (improver); |
732 | improver->decrease (); |
730 | weapon->item_power++; |
733 | weapon->item_power++; |
731 | return 1; |
734 | return 1; |
732 | } |
735 | } |
733 | |
736 | |
734 | sacrifice_needed = weapon->stats.Str + weapon->stats.Int + weapon->stats.Dex + |
737 | sacrifice_needed = weapon->stats.Str + weapon->stats.Int + weapon->stats.Dex + |
… | |
… | |
834 | if (armour->magic >= settings.armor_max_enchant) |
837 | if (armour->magic >= settings.armor_max_enchant) |
835 | { |
838 | { |
836 | op->failmsg ("This armour can not be enchanted any further!"); |
839 | op->failmsg ("This armour can not be enchanted any further!"); |
837 | return 0; |
840 | return 0; |
838 | } |
841 | } |
|
|
842 | |
839 | /* Dealing with random artifact armor is a lot trickier (in terms of value, weight, |
843 | /* Dealing with random artifact armor is a lot trickier (in terms of value, weight, |
840 | * etc), so take the easy way out and don't worry about it. |
844 | * etc), so take the easy way out and don't worry about it. |
841 | * Note - maybe add scrolls which make the random artifact versions (eg, armour |
845 | * Note - maybe add scrolls which make the random artifact versions (eg, armour |
842 | * of gnarg and what not?) |
846 | * of gnarg and what not?) |
843 | */ |
847 | */ |
… | |
… | |
845 | { |
849 | { |
846 | op->failmsg ("This armour will not accept further enchantment."); |
850 | op->failmsg ("This armour will not accept further enchantment."); |
847 | return 0; |
851 | return 0; |
848 | } |
852 | } |
849 | |
853 | |
850 | /* Split objects if needed. Can't insert tmp until the |
854 | /* Split objects if needed. Can't insert tmp until the |
851 | * end of this function - otherwise it will just re-merge. |
855 | * end of this function - otherwise it will just re-merge. |
852 | */ |
856 | */ |
853 | if (armour->nrof > 1) |
857 | tmp = armour->nrof > 1 ? armour->split (armour->nrof - 1) : 0; |
854 | tmp = get_split_ob (armour, armour->nrof - 1); |
|
|
855 | else |
|
|
856 | tmp = NULL; |
|
|
857 | |
858 | |
858 | armour->magic++; |
859 | armour->magic++; |
859 | |
860 | |
860 | if (!settings.armor_speed_linear) |
861 | if (!settings.armor_speed_linear) |
861 | { |
862 | { |
… | |
… | |
902 | esrv_send_item (op, armour); |
903 | esrv_send_item (op, armour); |
903 | if (QUERY_FLAG (armour, FLAG_APPLIED)) |
904 | if (QUERY_FLAG (armour, FLAG_APPLIED)) |
904 | op->update_stats (); |
905 | op->update_stats (); |
905 | } |
906 | } |
906 | |
907 | |
907 | decrease_ob (improver); |
908 | improver->decrease (); |
908 | |
909 | |
909 | if (tmp) |
910 | if (tmp) |
910 | { |
911 | { |
911 | insert_ob_in_ob (tmp, op); |
912 | insert_ob_in_ob (tmp, op); |
912 | esrv_send_item (op, tmp); |
913 | esrv_send_item (op, tmp); |
… | |
… | |
916 | } |
917 | } |
917 | |
918 | |
918 | /* |
919 | /* |
919 | * convert_item() returns 1 if anything was converted, 0 if the item was not |
920 | * convert_item() returns 1 if anything was converted, 0 if the item was not |
920 | * what the converter wants, -1 if the converter is broken. |
921 | * what the converter wants, -1 if the converter is broken. |
921 | */ |
922 | * |
922 | #define CONV_FROM(xyz) xyz->slaying |
|
|
923 | #define CONV_TO(xyz) xyz->other_arch |
|
|
924 | #define CONV_NR(xyz) xyz->stats.sp |
|
|
925 | #define CONV_NEED(xyz) xyz->stats.food |
|
|
926 | |
|
|
927 | /* Takes one items and makes another. |
923 | * Takes one type of items and makes another. |
928 | * converter is the object that is doing the conversion. |
924 | * converter is the object that is doing the conversion. |
929 | * item is the object that triggered the converter - if it is not |
925 | * item is the object that triggered the converter - if it is not |
930 | * what the converter wants, this will not do anything. |
926 | * what the converter wants, this will not do anything. |
931 | */ |
927 | */ |
932 | int |
928 | static int |
933 | convert_item (object *item, object *converter) |
929 | convert_item (object *item, object *converter) |
934 | { |
930 | { |
935 | int nr = 0; |
|
|
936 | uint32 price_in; |
931 | sint64 nr, price_in; |
|
|
932 | |
|
|
933 | if (item->flag [FLAG_UNPAID]) |
|
|
934 | return 0; |
|
|
935 | |
|
|
936 | shstr conv_from = converter->slaying; |
|
|
937 | archetype *conv_to = converter->other_arch; |
|
|
938 | sint64 need = converter->stats.food; |
|
|
939 | sint64 give = converter->stats.sp; |
937 | |
940 | |
938 | /* We make some assumptions - we assume if it takes money as it type, |
941 | /* We make some assumptions - we assume if it takes money as it type, |
939 | * it wants some amount. We don't make change (ie, if something costs |
942 | * it wants some amount. We don't make change (ie, if something costs |
940 | * 3 gp and player drops a platinum, tough luck) |
943 | * 3 gp and player drops a platinum, tough luck) |
941 | */ |
944 | */ |
942 | if (CONV_FROM (converter) == shstr_money) |
945 | if (conv_from == shstr_money) |
943 | { |
946 | { |
944 | if (item->type != MONEY) |
947 | if (item->type != MONEY) |
945 | return 0; |
948 | return 0; |
946 | |
949 | |
947 | nr = (item->nrof * item->value) / CONV_NEED (converter); |
950 | nr = sint64 (item->nrof) * item->value / need; |
948 | if (!nr) |
951 | if (!nr) |
949 | return 0; |
952 | return 0; |
950 | |
953 | |
951 | converter->play_sound (sound_find ("shop_buy")); |
954 | converter->play_sound (sound_find ("shop_buy")); |
952 | |
955 | |
953 | int cost = nr * CONV_NEED (converter) / item->value; |
956 | sint64 cost = (nr * need + item->value - 1) / item->value; |
954 | /* take into account rounding errors */ |
|
|
955 | if (nr * CONV_NEED (converter) % item->value) |
|
|
956 | cost++; |
|
|
957 | |
957 | |
958 | decrease_ob_nr (item, cost); |
958 | item->decrease (cost); |
959 | |
959 | |
960 | price_in = cost * item->value; |
960 | price_in = cost * item->value; |
961 | } |
961 | } |
962 | else |
962 | else |
963 | { |
963 | { |
964 | if (item->type == PLAYER || CONV_FROM (converter) != item->arch->archname || |
964 | if (item->type == PLAYER |
965 | (CONV_NEED (converter) && CONV_NEED (converter) > (uint16) item->nrof)) |
965 | || conv_from != item->arch->archname |
|
|
966 | || (need && need > (uint16) item->nrof)) |
966 | return 0; |
967 | return 0; |
967 | |
968 | |
968 | converter->play_sound (sound_find ("convert_item")); |
969 | converter->play_sound (sound_find ("convert_item")); |
969 | |
970 | |
970 | if (CONV_NEED (converter)) |
971 | if (need) |
971 | { |
972 | { |
972 | nr = item->nrof / CONV_NEED (converter); |
973 | nr = sint64 (item->nrof) / need; |
973 | decrease_ob_nr (item, nr * CONV_NEED (converter)); |
974 | item->decrease (nr * need); |
974 | price_in = nr * CONV_NEED (converter) * item->value; |
975 | price_in = nr * need * item->value; |
975 | } |
976 | } |
976 | else |
977 | else |
977 | { |
978 | { |
978 | price_in = item->value; |
979 | price_in = item->value; |
979 | item->destroy (); |
980 | item->destroy (); |
… | |
… | |
996 | CLEAR_FLAG (item, FLAG_IS_A_TEMPLATE); |
997 | CLEAR_FLAG (item, FLAG_IS_A_TEMPLATE); |
997 | unflag_inv (item, FLAG_IS_A_TEMPLATE); |
998 | unflag_inv (item, FLAG_IS_A_TEMPLATE); |
998 | } |
999 | } |
999 | else |
1000 | else |
1000 | { |
1001 | { |
1001 | if (converter->other_arch == NULL) |
1002 | if (!conv_to) |
1002 | { |
1003 | { |
1003 | LOG (llevError, "move_creator: Converter doesn't have other arch set: %s (%s, %d, %d)\n", |
1004 | LOG (llevError, "move_creator: Converter doesn't have other arch set: %s (%s, %d, %d)\n", |
1004 | &converter->name, &converter->map->path, converter->x, converter->y); |
1005 | &converter->name, &converter->map->path, converter->x, converter->y); |
1005 | return -1; |
1006 | return -1; |
1006 | } |
1007 | } |
1007 | |
1008 | |
1008 | item = object_create_arch (converter->other_arch); |
1009 | item = object_create_arch (conv_to); |
1009 | fix_generated_item (item, converter, 0, 0, GT_MINIMAL); |
1010 | fix_generated_item (item, converter, 0, 0, GT_MINIMAL); |
1010 | } |
1011 | } |
1011 | |
1012 | |
1012 | if (CONV_NR (converter)) |
1013 | if (give) |
1013 | item->nrof = CONV_NR (converter); |
1014 | item->nrof = give; |
1014 | |
1015 | |
1015 | if (nr) |
1016 | if (nr) |
1016 | item->nrof *= nr; |
1017 | item->nrof *= nr; |
1017 | |
1018 | |
1018 | if (is_in_shop (converter)) |
1019 | if (is_in_shop (converter)) |
1019 | SET_FLAG (item, FLAG_UNPAID); |
1020 | SET_FLAG (item, FLAG_UNPAID); |
1020 | else if (price_in < item->nrof * item->value) |
1021 | else if (price_in < sint64 (item->nrof) * item->value) |
1021 | { |
1022 | { |
1022 | LOG (llevDebug, "converter output price higher than input: %s at %s (%d, %d) in value %d, out value %d for %s\n", |
1023 | LOG (llevDebug, "converter output price higher than input: %s at %s (%d, %d) in value %d, out value %d for %s\n", |
1023 | &converter->name, &converter->map->path, converter->x, converter->y, price_in, item->nrof * item->value, &item->name); |
1024 | &converter->name, &converter->map->path, converter->x, converter->y, price_in, item->nrof * item->value, &item->name); |
1024 | /** |
1025 | /** |
1025 | * elmex: we are going to let the game continue, as the mapcreator |
1026 | * elmex: we are going to let the game continue, as the mapcreator |
… | |
… | |
1310 | } |
1311 | } |
1311 | |
1312 | |
1312 | if (op->contr) |
1313 | if (op->contr) |
1313 | if (client *ns = op->contr->ns) |
1314 | if (client *ns = op->contr->ns) |
1314 | { |
1315 | { |
|
|
1316 | if (sign->sound) |
1315 | ns->play_sound (sign->sound); |
1317 | ns->play_sound (sign->sound); |
1316 | msgType = get_readable_message_type (sign); |
1318 | else if (autoapply) |
|
|
1319 | ns->play_sound (sound_find ("msg_voice")); |
1317 | |
1320 | |
1318 | if (ns->can_msg) |
1321 | if (ns->can_msg) |
1319 | ns->send_msg (NDI_NAVY, msgType->msgtype, &sign->msg); |
1322 | op->contr->infobox (MSG_CHANNEL ("examine"), format ("T<%s>\n\n\n\n%s", &sign->name, &sign->msg)); |
1320 | else |
1323 | else |
1321 | { |
1324 | { |
1322 | char newbuf[HUGE_BUF]; |
1325 | msgType = get_readable_message_type (sign); |
1323 | snprintf (newbuf, sizeof (newbuf), "%u %s", autoapply ? 1 : 0, &sign->msg); |
1326 | const char *somemsg = format ("%u %s", autoapply ? 1 : 0, &sign->msg); |
1324 | draw_ext_info (NDI_UNIQUE | NDI_NAVY, 0, op, msgType->message_type, msgType->message_subtype, newbuf, &sign->msg); |
1327 | draw_ext_info (NDI_UNIQUE | NDI_NAVY, 0, op, msgType->message_type, msgType->message_subtype, somemsg, &sign->msg); |
1325 | } |
1328 | } |
1326 | } |
1329 | } |
1327 | } |
1330 | } |
1328 | |
1331 | |
1329 | /** |
1332 | /** |
… | |
… | |
1443 | |
1446 | |
1444 | if (!trap->value) |
1447 | if (!trap->value) |
1445 | { |
1448 | { |
1446 | int tot; |
1449 | int tot; |
1447 | |
1450 | |
1448 | for (ab = trap->above, tot = 0; ab != NULL; ab = ab->above) |
1451 | for (ab = trap->above, tot = 0; ab; ab = ab->above) |
1449 | if ((ab->move_type && trap->move_on) || ab->move_type == 0) |
1452 | if ((ab->move_type && trap->move_on) || ab->move_type == 0) |
1450 | tot += (ab->nrof ? ab->nrof : 1) * ab->weight + ab->carrying; |
1453 | tot += ab->head_ ()->total_weight (); |
1451 | |
1454 | |
1452 | if (!(trap->value = (tot > trap->weight) ? 1 : 0)) |
1455 | if (!(trap->value = (tot > trap->weight) ? 1 : 0)) |
1453 | goto leave; |
1456 | goto leave; |
1454 | |
1457 | |
1455 | SET_ANIMATION (trap, trap->value); |
1458 | SET_ANIMATION (trap, trap->value); |
… | |
… | |
1524 | * players output. |
1527 | * players output. |
1525 | */ |
1528 | */ |
1526 | if (trap->msg && strncmp (EXIT_PATH (trap), "/!", 2)) |
1529 | if (trap->msg && strncmp (EXIT_PATH (trap), "/!", 2)) |
1527 | victim->statusmsg (trap->msg, NDI_NAVY); |
1530 | victim->statusmsg (trap->msg, NDI_NAVY); |
1528 | |
1531 | |
|
|
1532 | trap->play_sound (trap->sound); |
1529 | victim->enter_exit (trap); |
1533 | victim->enter_exit (trap); |
1530 | } |
1534 | } |
1531 | goto leave; |
1535 | goto leave; |
1532 | |
1536 | |
1533 | case ENCOUNTER: |
1537 | case ENCOUNTER: |
… | |
… | |
1600 | } |
1604 | } |
1601 | |
1605 | |
1602 | lev_diff = tmp->level - (skill_ob->level + 5); |
1606 | lev_diff = tmp->level - (skill_ob->level + 5); |
1603 | if (!QUERY_FLAG (op, FLAG_WIZ) && lev_diff > 0) |
1607 | if (!QUERY_FLAG (op, FLAG_WIZ) && lev_diff > 0) |
1604 | { |
1608 | { |
1605 | op->failmsg (lev_diff < 2 ? "This book is just barely beyond your comprehension." |
1609 | op->failmsg (lev_diff < 2 ? "This book is just barely beyond your comprehension." |
1606 | : lev_diff < 3 ? "This book is slightly beyond your comprehension." |
1610 | : lev_diff < 3 ? "This book is slightly beyond your comprehension." |
1607 | : lev_diff < 5 ? "This book is beyond your comprehension." |
1611 | : lev_diff < 5 ? "This book is beyond your comprehension." |
1608 | : lev_diff < 8 ? "This book is quite a bit beyond your comprehension." |
1612 | : lev_diff < 8 ? "This book is quite a bit beyond your comprehension." |
1609 | : lev_diff < 15 ? "This book is way beyond your comprehension." |
1613 | : lev_diff < 15 ? "This book is way beyond your comprehension." |
1610 | : "This book is totally beyond your comprehension."); |
1614 | : "This book is totally beyond your comprehension."); |
… | |
… | |
1614 | readable_message_type *msgType = get_readable_message_type (tmp); |
1618 | readable_message_type *msgType = get_readable_message_type (tmp); |
1615 | |
1619 | |
1616 | if (player *pl = op->contr) |
1620 | if (player *pl = op->contr) |
1617 | if (client *ns = pl->ns) |
1621 | if (client *ns = pl->ns) |
1618 | if (ns->can_msg) |
1622 | if (ns->can_msg) |
1619 | { |
1623 | pl->infobox (MSG_CHANNEL ("book"), format ("T<%s>\n\n\n\n%s", (char *)long_desc (tmp, op), &tmp->msg)); |
1620 | dynbuf_text buf; |
|
|
1621 | buf << long_desc (tmp, op) |
|
|
1622 | << "\n\n" |
|
|
1623 | << tmp->msg |
|
|
1624 | << '\0'; |
|
|
1625 | ns->send_msg (NDI_NAVY, msgType->msgtype, buf.linearise ()); |
|
|
1626 | } |
|
|
1627 | else |
1624 | else |
1628 | draw_ext_info_format (NDI_UNIQUE | NDI_NAVY, 0, op, |
1625 | draw_ext_info_format (NDI_UNIQUE | NDI_NAVY, 0, op, |
1629 | msgType->message_type, msgType->message_subtype, |
1626 | msgType->message_type, msgType->message_subtype, |
1630 | "You open the %s and start reading.\n%s", (char *)"%s\n%s", |
1627 | "You open the %s and start reading.\n%s", (char *)"%s\n%s", |
1631 | long_desc (tmp, op), &tmp->msg); |
1628 | long_desc (tmp, op), &tmp->msg); |
… | |
… | |
1665 | op->play_sound (sound_find ("generic_fail")); |
1662 | op->play_sound (sound_find ("generic_fail")); |
1666 | op->failmsg (format ("You already possess the knowledge held within the %s.", query_name (tmp))); |
1663 | op->failmsg (format ("You already possess the knowledge held within the %s.", query_name (tmp))); |
1667 | break; |
1664 | break; |
1668 | |
1665 | |
1669 | case 1: |
1666 | case 1: |
1670 | decrease_ob (tmp); |
1667 | tmp->decrease (); |
1671 | op->play_sound (sound_find ("skill_learn")); |
1668 | op->play_sound (sound_find ("skill_learn")); |
1672 | op->statusmsg (format ("You succeed in learning %s", &tmp->skill)); |
1669 | op->statusmsg (format ("You succeed in learning %s", &tmp->skill)); |
1673 | break; |
1670 | break; |
1674 | |
1671 | |
1675 | default: |
1672 | default: |
1676 | decrease_ob (tmp); |
1673 | tmp->decrease (); |
1677 | op->play_sound (sound_find ("generic_fail")); |
1674 | op->play_sound (sound_find ("generic_fail")); |
1678 | op->failmsg (format ("You fail to learn the knowledge of the %s.\n", query_name (tmp))); |
1675 | op->failmsg (format ("You fail to learn the knowledge of the %s.\n", query_name (tmp))); |
1679 | break; |
1676 | break; |
1680 | } |
1677 | } |
1681 | } |
1678 | } |
… | |
… | |
1872 | { |
1869 | { |
1873 | op->contr->play_sound (sound_find ("fumble_spell")); |
1870 | op->contr->play_sound (sound_find ("fumble_spell")); |
1874 | op->failmsg ("You fail to learn the spell. H<Wis (priests) or Int (wizards) governs the chance of learning a prayer or spell.>\n"); |
1871 | op->failmsg ("You fail to learn the spell. H<Wis (priests) or Int (wizards) governs the chance of learning a prayer or spell.>\n"); |
1875 | } |
1872 | } |
1876 | |
1873 | |
1877 | decrease_ob (tmp); |
1874 | tmp->decrease (); |
1878 | } |
1875 | } |
1879 | |
1876 | |
1880 | /** |
1877 | /** |
1881 | * Handles applying a spell scroll. |
1878 | * Handles applying a spell scroll. |
1882 | */ |
1879 | */ |
… | |
… | |
1921 | identify (tmp); |
1918 | identify (tmp); |
1922 | |
1919 | |
1923 | op->statusmsg (format ("The scroll of %s turns to dust.", &tmp->inv->name)); |
1920 | op->statusmsg (format ("The scroll of %s turns to dust.", &tmp->inv->name)); |
1924 | |
1921 | |
1925 | cast_spell (op, tmp, dir, tmp->inv, NULL); |
1922 | cast_spell (op, tmp, dir, tmp->inv, NULL); |
1926 | decrease_ob (tmp); |
1923 | tmp->decrease (); |
1927 | } |
1924 | } |
1928 | |
1925 | |
1929 | /** |
1926 | /** |
1930 | * Applies a treasure object - by default, chest. op |
1927 | * Applies a treasure object - by default, chest. op |
1931 | * is the person doing the applying, tmp is the treasure |
1928 | * is the person doing the applying, tmp is the treasure |
… | |
… | |
1943 | object *treas = tmp->inv; |
1940 | object *treas = tmp->inv; |
1944 | |
1941 | |
1945 | if (!treas) |
1942 | if (!treas) |
1946 | { |
1943 | { |
1947 | op->statusmsg ("The chest was empty."); |
1944 | op->statusmsg ("The chest was empty."); |
1948 | decrease_ob (tmp); |
1945 | tmp->decrease (); |
1949 | return; |
1946 | return; |
1950 | } |
1947 | } |
1951 | |
1948 | |
1952 | while (tmp->inv) |
1949 | while (tmp->inv) |
1953 | { |
1950 | { |
… | |
… | |
1969 | if (op->destroyed () || tmp->destroyed ()) |
1966 | if (op->destroyed () || tmp->destroyed ()) |
1970 | break; |
1967 | break; |
1971 | } |
1968 | } |
1972 | |
1969 | |
1973 | if (!tmp->destroyed () && !tmp->inv) |
1970 | if (!tmp->destroyed () && !tmp->inv) |
1974 | decrease_ob (tmp); |
1971 | tmp->decrease (); |
1975 | } |
1972 | } |
1976 | |
1973 | |
1977 | /** |
1974 | /** |
1978 | * op eats food. |
1975 | * op eats food. |
1979 | * If player, takes care of messages and dragon special food. |
1976 | * If player, takes care of messages and dragon special food. |
… | |
… | |
1998 | if (tmp->type == FOOD || tmp->type == FLESH) |
1995 | if (tmp->type == FOOD || tmp->type == FLESH) |
1999 | op->failmsg ("You feel full, but what a waste of food!"); |
1996 | op->failmsg ("You feel full, but what a waste of food!"); |
2000 | else |
1997 | else |
2001 | op->statusmsg ("Most of the drink goes down your face not your throat!"); |
1998 | op->statusmsg ("Most of the drink goes down your face not your throat!"); |
2002 | } |
1999 | } |
|
|
2000 | |
|
|
2001 | tmp->play_sound ( |
|
|
2002 | tmp->sound |
|
|
2003 | ? tmp->sound |
|
|
2004 | : tmp->type == DRINK |
|
|
2005 | ? sound_find ("eat_drink") |
|
|
2006 | : sound_find ("eat_food") |
|
|
2007 | ); |
2003 | |
2008 | |
2004 | if (!QUERY_FLAG (tmp, FLAG_CURSED)) |
2009 | if (!QUERY_FLAG (tmp, FLAG_CURSED)) |
2005 | { |
2010 | { |
2006 | const char *buf; |
2011 | const char *buf; |
2007 | |
2012 | |
… | |
… | |
2037 | eat_special_food (op, tmp); |
2042 | eat_special_food (op, tmp); |
2038 | } |
2043 | } |
2039 | } |
2044 | } |
2040 | |
2045 | |
2041 | handle_apply_yield (tmp); |
2046 | handle_apply_yield (tmp); |
2042 | decrease_ob (tmp); |
2047 | tmp->decrease (); |
2043 | } |
2048 | } |
2044 | |
2049 | |
2045 | /** |
2050 | /** |
2046 | * A dragon is eating some flesh. If the flesh contains resistances, |
2051 | * A dragon is eating some flesh. If the flesh contains resistances, |
2047 | * there is a chance for the dragon's skin to get improved. |
2052 | * there is a chance for the dragon's skin to get improved. |
… | |
… | |
2253 | hit_player (op, tmp->stats.hp, tmp, AT_POISON, 1); |
2258 | hit_player (op, tmp->stats.hp, tmp, AT_POISON, 1); |
2254 | } |
2259 | } |
2255 | |
2260 | |
2256 | op->stats.food -= op->stats.food / 4; |
2261 | op->stats.food -= op->stats.food / 4; |
2257 | handle_apply_yield (tmp); |
2262 | handle_apply_yield (tmp); |
2258 | decrease_ob (tmp); |
2263 | tmp->decrease (); |
2259 | } |
2264 | } |
2260 | |
2265 | |
2261 | /** |
2266 | /** |
2262 | * This function return true if the exit is not a 2 ways one or it is 2 ways, valid exit. |
2267 | * This function return true if the exit is not a 2 ways one or it is 2 ways, valid exit. |
2263 | * A valid 2 way exit means: |
2268 | * A valid 2 way exit means: |
… | |
… | |
2278 | |
2283 | |
2279 | #if 0 //TODO |
2284 | #if 0 //TODO |
2280 | if (!has_been_loaded (EXIT_PATH (exit)) && exit->race) |
2285 | if (!has_been_loaded (EXIT_PATH (exit)) && exit->race) |
2281 | return 0; /* This is a reset town portal */ |
2286 | return 0; /* This is a reset town portal */ |
2282 | #endif |
2287 | #endif |
|
|
2288 | |
|
|
2289 | LOG (llevError | logBacktrace, "sync map load due to %s\n", exit->debug_desc ()); |
2283 | |
2290 | |
2284 | maptile *exitmap = maptile::find_sync (EXIT_PATH (exit), exit->map); |
2291 | maptile *exitmap = maptile::find_sync (EXIT_PATH (exit), exit->map); |
2285 | |
2292 | |
2286 | if (exitmap) |
2293 | if (exitmap) |
2287 | { |
2294 | { |
… | |
… | |
2599 | if (op->env && (pl->move_type & MOVE_FLYING)) |
2606 | if (op->env && (pl->move_type & MOVE_FLYING)) |
2600 | { |
2607 | { |
2601 | /* player is flying and applying object not in inventory */ |
2608 | /* player is flying and applying object not in inventory */ |
2602 | if (!QUERY_FLAG (pl, FLAG_WIZ) && !(op->move_type & MOVE_FLYING)) |
2609 | if (!QUERY_FLAG (pl, FLAG_WIZ) && !(op->move_type & MOVE_FLYING)) |
2603 | { |
2610 | { |
2604 | op->failmsg ("But you are floating high above the ground! H<You have to stop levitating first, if you can.>"); |
2611 | pl->failmsg ("But you are floating high above the ground! H<You have to stop levitating first, if you can.>"); |
2605 | return 0; |
2612 | return 0; |
2606 | } |
2613 | } |
2607 | } |
2614 | } |
2608 | |
2615 | |
2609 | pl->contr->last_used = op; |
2616 | pl->contr->last_used = op; |
2610 | |
2617 | |
2611 | tmp = manual_apply (pl, op, aflag); |
2618 | tmp = manual_apply (pl, op, aflag); |
2612 | if (!quiet) |
2619 | if (!quiet) |
2613 | { |
2620 | { |
2614 | if (tmp == 0) |
2621 | if (tmp == 0) |
2615 | op->statusmsg (format ("I don't know how to apply the %s.", query_name (op))); |
2622 | pl->statusmsg (format ("I don't know how to apply the %s.", query_name (op))); |
2616 | else if (tmp == 2) |
2623 | else if (tmp == 2) |
2617 | op->failmsg ("You must get it first!\n"); |
2624 | pl->failmsg ("You must get it first!\n"); |
2618 | } |
2625 | } |
2619 | |
2626 | |
2620 | return tmp; |
2627 | return tmp; |
2621 | } |
2628 | } |
2622 | |
2629 | |
… | |
… | |
2747 | tmp2->stats.food = op->stats.food; |
2754 | tmp2->stats.food = op->stats.food; |
2748 | CLEAR_FLAG (tmp2, FLAG_APPLIED); |
2755 | CLEAR_FLAG (tmp2, FLAG_APPLIED); |
2749 | |
2756 | |
2750 | if (QUERY_FLAG (op, FLAG_INV_LOCKED)) |
2757 | if (QUERY_FLAG (op, FLAG_INV_LOCKED)) |
2751 | SET_FLAG (tmp2, FLAG_INV_LOCKED); |
2758 | SET_FLAG (tmp2, FLAG_INV_LOCKED); |
2752 | |
|
|
2753 | if (who->contr) |
|
|
2754 | esrv_del_item (who->contr, op->count); |
|
|
2755 | |
2759 | |
2756 | op->destroy (); |
2760 | op->destroy (); |
2757 | insert_ob_in_ob (tmp2, who); |
2761 | insert_ob_in_ob (tmp2, who); |
2758 | who->update_stats (); |
2762 | who->update_stats (); |
2759 | |
2763 | |
… | |
… | |
3211 | |
3215 | |
3212 | /* Ok. We are now at the state where we can apply the new object. |
3216 | /* Ok. We are now at the state where we can apply the new object. |
3213 | * Note that we don't have the checks for can_use_... |
3217 | * Note that we don't have the checks for can_use_... |
3214 | * below - that is already taken care of by can_apply_object. |
3218 | * below - that is already taken care of by can_apply_object. |
3215 | */ |
3219 | */ |
3216 | if (op->nrof > 1) |
3220 | tmp = op->nrof > 1 ? op->split (op->nrof - 1) : 0; |
3217 | tmp = get_split_ob (op, op->nrof - 1); |
|
|
3218 | else |
|
|
3219 | tmp = 0; |
|
|
3220 | |
3221 | |
3221 | if (INVOKE_OBJECT (BE_READY, op, ARG_OBJECT (who)) || INVOKE_OBJECT (READY, who, ARG_OBJECT (op))) |
3222 | if (INVOKE_OBJECT (BE_READY, op, ARG_OBJECT (who)) || INVOKE_OBJECT (READY, who, ARG_OBJECT (op))) |
3222 | return RESULT_INT (0); |
3223 | return RESULT_INT (0); |
3223 | |
3224 | |
3224 | switch (op->type) |
3225 | switch (op->type) |
… | |
… | |
3302 | SET_FLAG (tmp2, FLAG_INV_LOCKED); |
3303 | SET_FLAG (tmp2, FLAG_INV_LOCKED); |
3303 | |
3304 | |
3304 | insert_ob_in_ob (tmp2, who); |
3305 | insert_ob_in_ob (tmp2, who); |
3305 | |
3306 | |
3306 | /* Remove the old lantern */ |
3307 | /* Remove the old lantern */ |
3307 | if (who->type == PLAYER) |
|
|
3308 | esrv_del_item (who->contr, op->count); |
|
|
3309 | |
|
|
3310 | op->destroy (); |
3308 | op->destroy (); |
3311 | |
3309 | |
3312 | /* insert the portion that was split off */ |
3310 | /* insert the portion that was split off */ |
3313 | if (tmp) |
3311 | if (tmp) |
3314 | { |
3312 | { |
… | |
… | |
4092 | pl->statusmsg (format ("You %s the %s.", &transformer->slaying, query_base_name (marked, 0))); |
4090 | pl->statusmsg (format ("You %s the %s.", &transformer->slaying, query_base_name (marked, 0))); |
4093 | |
4091 | |
4094 | insert_ob_in_ob (new_item, pl); |
4092 | insert_ob_in_ob (new_item, pl); |
4095 | esrv_send_inventory (pl, pl); |
4093 | esrv_send_inventory (pl, pl); |
4096 | /* Eat up one item */ |
4094 | /* Eat up one item */ |
4097 | decrease_ob_nr (marked, 1); |
4095 | marked->decrease (); |
4098 | |
4096 | |
4099 | /* Eat one transformer if needed */ |
4097 | /* Eat one transformer if needed */ |
4100 | if (transformer->stats.food) |
4098 | if (transformer->stats.food) |
4101 | if (--transformer->stats.food == 0) |
4099 | if (--transformer->stats.food == 0) |
4102 | decrease_ob_nr (transformer, 1); |
4100 | transformer->decrease (); |
4103 | } |
4101 | } |
4104 | |
4102 | |