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

Comparing deliantra/server/server/monster.C (file contents):
Revision 1.25 by elmex, Mon Apr 16 11:50:44 2007 UTC vs.
Revision 1.38 by root, Thu Aug 23 16:46:28 2007 UTC

1/* 1/*
2 * CrossFire, A Multiplayer game for X-windows 2 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3 * 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team 4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify 8 * Crossfire TRT 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 2 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,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
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, write to the Free Software 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 * 20 *
22 * The authors can be reached via e-mail at <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <crossfire@schmorp.de>
23 */ 22 */
24 23
25#include <global.h> 24#include <global.h>
26#include <sproto.h> 25#include <sproto.h>
27#include <spells.h> 26#include <spells.h>
… …
85 * target enemy - this code below makes sure the enemy is something 84 * target enemy - this code below makes sure the enemy is something
86 * that should be attacked. My guess is that the arrow hits 85 * that should be attacked. My guess is that the arrow hits
87 * the creature/owner, and so the creature then takes that 86 * the creature/owner, and so the creature then takes that
88 * as the enemy to attack. 87 * as the enemy to attack.
89 */ 88 */
90 else if (!QUERY_FLAG (npc->enemy, FLAG_MONSTER) && 89 else if (!QUERY_FLAG (npc->enemy, FLAG_MONSTER)
91 !QUERY_FLAG (npc->enemy, FLAG_GENERATOR) && npc->enemy->type != PLAYER && npc->enemy->type != GOLEM) 90 && !QUERY_FLAG (npc->enemy, FLAG_GENERATOR)
91 && npc->enemy->type != PLAYER
92 && npc->enemy->type != GOLEM)
92 npc->enemy = NULL; 93 npc->enemy = NULL;
93 94
94 } 95 }
96
95 return can_detect_enemy (npc, npc->enemy, rv) ? npc->enemy : NULL; 97 return can_detect_enemy (npc, npc->enemy, rv) ? npc->enemy : NULL;
96} 98}
97 99
98/* Returns the nearest living creature (monster or generator). 100/* Returns the nearest living creature (monster or generator).
99 * Modified to deal with tiled maps properly. 101 * Modified to deal with tiled maps properly.
… …
143 } 145 }
144 146
145 return 0; 147 return 0;
146} 148}
147 149
148
149/* Tries to find an enmy for npc. We pass the range vector since 150/* Tries to find an enemy for npc. We pass the range vector since
150 * our caller will find the information useful. 151 * our caller will find the information useful.
151 * Currently, only move_monster calls this function. 152 * Currently, only move_monster calls this function.
152 * Fix function so that we always make calls to get_rangevector 153 * Fix function so that we always make calls to get_rangevector
153 * if we have a valid target - function as not doing so in 154 * if we have a valid target - function as not doing so in
154 * many cases. 155 * many cases.
155 */ 156 */
156
157object * 157object *
158find_enemy (object *npc, rv_vector * rv) 158find_enemy (object *npc, rv_vector * rv)
159{ 159{
160 object *attacker, *tmp = NULL; 160 object *attacker, *tmp = NULL;
161 161
… …
167 { 167 {
168 tmp = find_nearest_living_creature (npc); 168 tmp = find_nearest_living_creature (npc);
169 169
170 if (tmp) 170 if (tmp)
171 get_rangevector (npc, tmp, rv, 0); 171 get_rangevector (npc, tmp, rv, 0);
172
172 return tmp; 173 return tmp;
173 } 174 }
174 175
175 /* Here is the main enemy selection. 176 /* Here is the main enemy selection.
176 * We want this: if there is an enemy, attack him until its not possible or 177 * We want this: if there is an enemy, attack him until its not possible or
… …
229/* Sees if this monster should wake up. 230/* Sees if this monster should wake up.
230 * Currently, this is only called from move_monster, and 231 * Currently, this is only called from move_monster, and
231 * if enemy is set, then so should be rv. 232 * if enemy is set, then so should be rv.
232 * returns 1 if the monster should wake up, 0 otherwise. 233 * returns 1 if the monster should wake up, 0 otherwise.
233 */ 234 */
234
235int 235int
236check_wakeup (object *op, object *enemy, rv_vector * rv) 236check_wakeup (object *op, object *enemy, rv_vector * rv)
237{ 237{
238 int radius = op->stats.Wis > MIN_MON_RADIUS ? op->stats.Wis : MIN_MON_RADIUS; 238 int radius = op->stats.Wis > MIN_MON_RADIUS ? op->stats.Wis : MIN_MON_RADIUS;
239 239
… …
287} 287}
288 288
289/* 289/*
290 * Move-monster returns 1 if the object has been freed, otherwise 0. 290 * Move-monster returns 1 if the object has been freed, otherwise 0.
291 */ 291 */
292
293int 292int
294move_monster (object *op) 293move_monster (object *op)
295{ 294{
296 int dir, diff, pre_att_dir; /* elmex: pre_att_dir remembers the direction before attack movement */ 295 int dir, diff, pre_att_dir; /* elmex: pre_att_dir remembers the direction before attack movement */
297 object *owner, *enemy, *part, *oph = op; 296 object *owner, *enemy, *part, *oph = op;
… …
478 if (!QUERY_FLAG (op, FLAG_SCARED)) 477 if (!QUERY_FLAG (op, FLAG_SCARED))
479 { 478 {
480 rv_vector rv1; 479 rv_vector rv1;
481 480
482 /* now we test every part of an object .... this is a real ugly piece of code */ 481 /* now we test every part of an object .... this is a real ugly piece of code */
483 for (part = op; part != NULL; part = part->more) 482 for (part = op; part; part = part->more)
484 { 483 {
485 get_rangevector (part, enemy, &rv1, 0x1); 484 get_rangevector (part, enemy, &rv1, 0x1);
486 dir = rv1.direction; 485 dir = rv1.direction;
487 486
488 /* hm, not sure about this part - in original was a scared flag here too 487 /* hm, not sure about this part - in original was a scared flag here too
489 * but that we test above... so can be old code here 488 * but that we test above... so can be old code here
490 */ 489 */
491 if (QUERY_FLAG (op, FLAG_RUN_AWAY)) 490 if (QUERY_FLAG (op, FLAG_RUN_AWAY))
492 dir = absdir (dir + 4); 491 dir = absdir (dir + 4);
492
493 if (QUERY_FLAG (op, FLAG_CONFUSED)) 493 if (QUERY_FLAG (op, FLAG_CONFUSED))
494 dir = absdir (dir + rndm (3) + rndm (3) - 2); 494 dir = absdir (dir + rndm (3) + rndm (3) - 2);
495 495
496 if (QUERY_FLAG (op, FLAG_CAST_SPELL) && !(rndm (3))) 496 if (QUERY_FLAG (op, FLAG_CAST_SPELL) && !(rndm (3)))
497 {
498 if (monster_cast_spell (op, part, enemy, dir, &rv1)) 497 if (monster_cast_spell (op, part, enemy, dir, &rv1))
499 return 0; 498 return 0;
500 }
501 499
502 if (QUERY_FLAG (op, FLAG_READY_SCROLL) && !(rndm (3))) 500 if (QUERY_FLAG (op, FLAG_READY_SCROLL) && !(rndm (3)))
503 {
504 if (monster_use_scroll (op, part, enemy, dir, &rv1)) 501 if (monster_use_scroll (op, part, enemy, dir, &rv1))
505 return 0; 502 return 0;
506 }
507 503
508 if (QUERY_FLAG (op, FLAG_READY_RANGE) && !(rndm (3))) 504 if (QUERY_FLAG (op, FLAG_READY_RANGE) && !(rndm (3)))
509 {
510 if (monster_use_range (op, part, enemy, dir)) 505 if (monster_use_range (op, part, enemy, dir))
511 return 0; 506 return 0;
512 } 507
513 if (QUERY_FLAG (op, FLAG_READY_SKILL) && !(rndm (3))) 508 if (QUERY_FLAG (op, FLAG_READY_SKILL) && !(rndm (3)))
514 {
515 if (monster_use_skill (op, rv.part, enemy, rv.direction)) 509 if (monster_use_skill (op, rv.part, enemy, rv.direction))
516 return 0; 510 return 0;
517 } 511
518 if (QUERY_FLAG (op, FLAG_READY_BOW) && !(rndm (2))) 512 if (QUERY_FLAG (op, FLAG_READY_BOW) && !(rndm (2)))
519 {
520 if (monster_use_bow (op, part, enemy, dir)) 513 if (monster_use_bow (op, part, enemy, dir))
521 return 0; 514 return 0;
522 }
523 } /* for processing of all parts */ 515 } /* for processing of all parts */
524 } /* If not scared */ 516 } /* If not scared */
525 517
526 518
527 part = rv.part; 519 part = rv.part;
… …
899 * The skills we are treating here are all but those. -b.t. 891 * The skills we are treating here are all but those. -b.t.
900 * 892 *
901 * At the moment this is only useful for throwing, perhaps for 893 * At the moment this is only useful for throwing, perhaps for
902 * stealing. TODO: This should be more integrated in the game. -MT, 25.11.01 894 * stealing. TODO: This should be more integrated in the game. -MT, 25.11.01
903 */ 895 */
904
905int 896int
906monster_use_skill (object *head, object *part, object *pl, int dir) 897monster_use_skill (object *head, object *part, object *pl, int dir)
907{ 898{
908 object *skill, *owner; 899 object *skill, *owner;
909 900
… …
915 int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y); 906 int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
916 907
917 if (dirdiff (dir, dir2) < 1) 908 if (dirdiff (dir, dir2) < 1)
918 return 0; /* Might hit owner with skill -thrown rocks for example ? */ 909 return 0; /* Might hit owner with skill -thrown rocks for example ? */
919 } 910 }
911
920 if (QUERY_FLAG (head, FLAG_CONFUSED)) 912 if (QUERY_FLAG (head, FLAG_CONFUSED))
921 dir = absdir (dir + rndm (3) + rndm (3) - 2); 913 dir = absdir (dir + rndm (3) + rndm (3) - 2);
922 914
923 /* skill selection - monster will use the next unused skill. 915 /* skill selection - monster will use the next unused skill.
924 * well...the following scenario will allow the monster to 916 * well...the following scenario will allow the monster to
925 * toggle between 2 skills. One day it would be nice to make 917 * toggle between 2 skills. One day it would be nice to make
926 * more skills available to monsters. 918 * more skills available to monsters.
927 */ 919 */
928
929 for (skill = head->inv; skill != NULL; skill = skill->below) 920 for (skill = head->inv; skill; skill = skill->below)
930 if (skill->type == SKILL && skill != head->chosen_skill) 921 if (skill->type == SKILL && skill != head->chosen_skill)
931 { 922 {
932 head->chosen_skill = skill; 923 head->chosen_skill = skill;
933 break; 924 break;
934 } 925 }
… …
937 { 928 {
938 LOG (llevDebug, "Error: Monster %s (%d) has FLAG_READY_SKILL without skill.\n", &head->name, head->count); 929 LOG (llevDebug, "Error: Monster %s (%d) has FLAG_READY_SKILL without skill.\n", &head->name, head->count);
939 CLEAR_FLAG (head, FLAG_READY_SKILL); 930 CLEAR_FLAG (head, FLAG_READY_SKILL);
940 return 0; 931 return 0;
941 } 932 }
933
942 /* use skill */ 934 /* use skill */
943 return do_skill (head, part, head->chosen_skill, dir, NULL); 935 return do_skill (head, part, head->chosen_skill, dir, NULL);
944} 936}
945 937
946/* Monster will use a ranged spell attack. */ 938/* Monster will use a ranged spell attack. */
947
948int 939int
949monster_use_range (object *head, object *part, object *pl, int dir) 940monster_use_range (object *head, object *part, object *pl, int dir)
950{ 941{
951 object *wand, *owner; 942 object *wand, *owner;
952 int at_least_one = 0; 943 int at_least_one = 0;
… …
959 int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y); 950 int dir2 = find_dir_2 (head->x - owner->x, head->y - owner->y);
960 951
961 if (dirdiff (dir, dir2) < 2) 952 if (dirdiff (dir, dir2) < 2)
962 return 0; /* Might hit owner with spell */ 953 return 0; /* Might hit owner with spell */
963 } 954 }
955
964 if (QUERY_FLAG (head, FLAG_CONFUSED)) 956 if (QUERY_FLAG (head, FLAG_CONFUSED))
965 dir = absdir (dir + rndm (3) + rndm (3) - 2); 957 dir = absdir (dir + rndm (3) + rndm (3) - 2);
966 958
967 for (wand = head->inv; wand != NULL; wand = wand->below) 959 for (wand = head->inv; wand; wand = wand->below)
968 { 960 {
969 if (wand->type == WAND) 961 if (wand->type == WAND)
970 { 962 {
971 /* Found a wand, let's see if it has charges left */ 963 /* Found a wand, let's see if it has charges left */
972 at_least_one = 1; 964 at_least_one = 1;
… …
978 if (!(--wand->stats.food)) 970 if (!(--wand->stats.food))
979 { 971 {
980 if (wand->arch) 972 if (wand->arch)
981 { 973 {
982 CLEAR_FLAG (wand, FLAG_ANIMATE); 974 CLEAR_FLAG (wand, FLAG_ANIMATE);
983 wand->face = wand->arch->clone.face; 975 wand->face = wand->arch->face;
984 wand->set_speed (0); 976 wand->set_speed (0);
985 } 977 }
986 } 978 }
987 /* Success */ 979 /* Success */
988 return 1; 980 return 1;
… …
1007 } 999 }
1008 1000
1009 if (at_least_one) 1001 if (at_least_one)
1010 return 0; 1002 return 0;
1011 1003
1012 LOG (llevError, "Error: Monster %s (%d) HAS_READY_RANG() without wand/horn/rod.\n", &head->name, head->count); 1004 LOG (llevError, "Error: Monster %s (%d) HAS_READY_RANGE() without wand/horn/rod.\n", &head->name, head->count);
1013 CLEAR_FLAG (head, FLAG_READY_RANGE); 1005 CLEAR_FLAG (head, FLAG_READY_RANGE);
1014 return 0; 1006 return 0;
1015} 1007}
1016 1008
1017int 1009int
… …
1019{ 1011{
1020 object *owner; 1012 object *owner;
1021 1013
1022 if (!(dir = path_to_player (part, pl, 0))) 1014 if (!(dir = path_to_player (part, pl, 0)))
1023 return 0; 1015 return 0;
1016
1024 if (QUERY_FLAG (head, FLAG_CONFUSED)) 1017 if (QUERY_FLAG (head, FLAG_CONFUSED))
1025 dir = absdir (dir + rndm (3) + rndm (3) - 2); 1018 dir = absdir (dir + rndm (3) + rndm (3) - 2);
1026 1019
1027 if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL) 1020 if (QUERY_FLAG (head, FLAG_FRIENDLY) && (owner = head->owner) != NULL)
1028 { 1021 {
… …
1036 return fire_bow (head, part, NULL, dir, 0, part->x, part->y); 1029 return fire_bow (head, part, NULL, dir, 0, part->x, part->y);
1037 1030
1038} 1031}
1039 1032
1040/* Checks if putting on 'item' will make 'who' do more 1033/* Checks if putting on 'item' will make 'who' do more
1041 * damage. This is a very simplistic check - also checking things 1034 * damage. This is a very simplistic check - also checking things
1042 * like speed and ac are also relevant. 1035 * like speed and ac are also relevant.
1043 * 1036 *
1044 * return true if item is a better object. 1037 * return true if item is a better object.
1045 */ 1038 */
1046
1047int 1039int
1048check_good_weapon (object *who, object *item) 1040check_good_weapon (object *who, object *item)
1049{ 1041{
1050 object *other_weap; 1042 object *other_weap;
1051 int val = 0, i; 1043 int val = 0, i;
1052 1044
1053 for (other_weap = who->inv; other_weap != NULL; other_weap = other_weap->below) 1045 for (other_weap = who->inv; other_weap; other_weap = other_weap->below)
1054 if (other_weap->type == item->type && QUERY_FLAG (other_weap, FLAG_APPLIED)) 1046 if (other_weap->type == item->type && QUERY_FLAG (other_weap, FLAG_APPLIED))
1055 break; 1047 break;
1056 1048
1057 if (other_weap == NULL) /* No other weapons */ 1049 if (!other_weap) /* No other weapons */
1058 return 1; 1050 return 1;
1059 1051
1060 /* Rather than go through and apply the new one, and see if it is 1052 /* Rather than go through and apply the new one, and see if it is
1061 * better, just do some simple checks 1053 * better, just do some simple checks
1062 * Put some multipliers for things that hvae several effects, 1054 * Put some multipliers for things that hvae several effects,
… …
1067 val += (item->magic - other_weap->magic) * 3; 1059 val += (item->magic - other_weap->magic) * 3;
1068 /* Monsters don't really get benefits from things like regen rates 1060 /* Monsters don't really get benefits from things like regen rates
1069 * from items. But the bonus for their stats are very important. 1061 * from items. But the bonus for their stats are very important.
1070 */ 1062 */
1071 for (i = 0; i < NUM_STATS; i++) 1063 for (i = 0; i < NUM_STATS; i++)
1072 val += (get_attr_value (&item->stats, i) - get_attr_value (&other_weap->stats, i)) * 2; 1064 val += item->stats.stat (i) - other_weap->stats.stat (i) * 2;
1073 1065
1074 if (val > 0) 1066 if (val > 0)
1075 return 1; 1067 return 1;
1076 else 1068 else
1077 return 0; 1069 return 0;
1078
1079} 1070}
1080 1071
1081int 1072int
1082check_good_armour (object *who, object *item) 1073check_good_armour (object *who, object *item)
1083{ 1074{
1084 object *other_armour; 1075 object *other_armour;
1085 int val = 0, i; 1076 int val = 0, i;
1086 1077
1087 for (other_armour = who->inv; other_armour != NULL; other_armour = other_armour->below) 1078 for (other_armour = who->inv; other_armour; other_armour = other_armour->below)
1088 if (other_armour->type == item->type && QUERY_FLAG (other_armour, FLAG_APPLIED)) 1079 if (other_armour->type == item->type && QUERY_FLAG (other_armour, FLAG_APPLIED))
1089 break; 1080 break;
1090 1081
1091 if (other_armour == NULL) /* No other armour, use the new */ 1082 if (other_armour == NULL) /* No other armour, use the new */
1092 return 1; 1083 return 1;
… …
1114 1105
1115 if (val > 0) 1106 if (val > 0)
1116 return 1; 1107 return 1;
1117 else 1108 else
1118 return 0; 1109 return 0;
1119
1120} 1110}
1121 1111
1122/* 1112/*
1123 * monster_check_pickup(): checks for items that monster can pick up. 1113 * monster_check_pickup(): checks for items that monster can pick up.
1124 * 1114 *
… …
1132 * This function was seen be continueing looping at one point (tmp->below 1122 * This function was seen be continueing looping at one point (tmp->below
1133 * became a recursive loop. It may be better to call monster_check_apply 1123 * became a recursive loop. It may be better to call monster_check_apply
1134 * after we pick everything up, since that function may call others which 1124 * after we pick everything up, since that function may call others which
1135 * affect stacking on this space. 1125 * affect stacking on this space.
1136 */ 1126 */
1137
1138void 1127void
1139monster_check_pickup (object *monster) 1128monster_check_pickup (object *monster)
1140{ 1129{
1141 object *tmp, *next; 1130 object *tmp, *next;
1142 1131
… …
1161 * monster_can_pick(): If the monster is interested in picking up 1150 * monster_can_pick(): If the monster is interested in picking up
1162 * the item, then return 0. Otherwise 0. 1151 * the item, then return 0. Otherwise 0.
1163 * Instead of pick_up, flags for "greed", etc, should be used. 1152 * Instead of pick_up, flags for "greed", etc, should be used.
1164 * I've already utilized flags for bows, wands, rings, etc, etc. -Frank. 1153 * I've already utilized flags for bows, wands, rings, etc, etc. -Frank.
1165 */ 1154 */
1166
1167int 1155int
1168monster_can_pick (object *monster, object *item) 1156monster_can_pick (object *monster, object *item)
1169{ 1157{
1170 int flag = 0; 1158 int flag = 0;
1171 int i; 1159 int i;
… …
1217 case ROD: 1205 case ROD:
1218 flag = QUERY_FLAG (monster, FLAG_USE_RANGE); 1206 flag = QUERY_FLAG (monster, FLAG_USE_RANGE);
1219 break; 1207 break;
1220 1208
1221 case SPELLBOOK: 1209 case SPELLBOOK:
1222 flag = (monster->arch != NULL && QUERY_FLAG ((&monster->arch->clone), FLAG_CAST_SPELL)); 1210 flag = monster->arch && QUERY_FLAG (monster->arch, FLAG_CAST_SPELL);
1223 break; 1211 break;
1224 1212
1225 case SCROLL: 1213 case SCROLL:
1226 flag = QUERY_FLAG (monster, FLAG_USE_SCROLL); 1214 flag = QUERY_FLAG (monster, FLAG_USE_SCROLL);
1227 break; 1215 break;
… …
1229 case BOW: 1217 case BOW:
1230 case ARROW: 1218 case ARROW:
1231 flag = QUERY_FLAG (monster, FLAG_USE_BOW); 1219 flag = QUERY_FLAG (monster, FLAG_USE_BOW);
1232 break; 1220 break;
1233 } 1221 }
1222
1234 /* Simplistic check - if the monster has a location to equip it, he will 1223 /* Simplistic check - if the monster has a location to equip it, he will
1235 * pick it up. Note that this doesn't handle cases where an item may 1224 * pick it up. Note that this doesn't handle cases where an item may
1236 * use several locations. 1225 * use several locations.
1237 */ 1226 */
1238 for (i = 0; i < NUM_BODY_LOCATIONS; i++) 1227 for (i = 0; i < NUM_BODY_LOCATIONS; i++)
1239 { 1228 {
1240 if (monster->body_info[i] && item->body_info[i]) 1229 if (monster->slot[i].info && item->slot[i].info)
1241 { 1230 {
1242 flag = 1; 1231 flag = 1;
1243 break; 1232 break;
1244 } 1233 }
1245 } 1234 }
… …
1253 * monster_apply_below(): 1242 * monster_apply_below():
1254 * Vick's (vick@bern.docs.uu.se) @921107 -> If a monster who's 1243 * Vick's (vick@bern.docs.uu.se) @921107 -> If a monster who's
1255 * eager to apply things, encounters something apply-able, 1244 * eager to apply things, encounters something apply-able,
1256 * then make him apply it 1245 * then make him apply it
1257 */ 1246 */
1258
1259void 1247void
1260monster_apply_below (object *monster) 1248monster_apply_below (object *monster)
1261{ 1249{
1262 object *tmp, *next; 1250 object *tmp, *next;
1263 1251
… …
1290 * a pointer to that object is returned, so it can be dropped. 1278 * a pointer to that object is returned, so it can be dropped.
1291 * (so that other monsters can pick it up and use it) 1279 * (so that other monsters can pick it up and use it)
1292 * Note that as things are now, monsters never drop something - 1280 * Note that as things are now, monsters never drop something -
1293 * they can pick up all that they can use. 1281 * they can pick up all that they can use.
1294 */ 1282 */
1295
1296/* Sept 96, fixed this so skills will be readied -b.t.*/ 1283/* Sept 96, fixed this so skills will be readied -b.t.*/
1297
1298void 1284void
1299monster_check_apply (object *mon, object *item) 1285monster_check_apply (object *mon, object *item)
1300{ 1286{
1301
1302 int flag = 0; 1287 int flag = 0;
1303 1288
1304 if (item->type == SPELLBOOK && mon->arch != NULL && (QUERY_FLAG ((&mon->arch->clone), FLAG_CAST_SPELL))) 1289 if (item->type == SPELLBOOK && mon->arch && (QUERY_FLAG (mon->arch, FLAG_CAST_SPELL)))
1305 { 1290 {
1306 SET_FLAG (mon, FLAG_CAST_SPELL); 1291 SET_FLAG (mon, FLAG_CAST_SPELL);
1307 return; 1292 return;
1308 } 1293 }
1309 1294
… …
1318 if (QUERY_FLAG (mon, FLAG_USE_BOW) && item->type == ARROW) 1303 if (QUERY_FLAG (mon, FLAG_USE_BOW) && item->type == ARROW)
1319 { 1304 {
1320 /* Check for the right kind of bow */ 1305 /* Check for the right kind of bow */
1321 object *bow; 1306 object *bow;
1322 1307
1323 for (bow = mon->inv; bow != NULL; bow = bow->below) 1308 for (bow = mon->inv; bow; bow = bow->below)
1324 if (bow->type == BOW && bow->race == item->race) 1309 if (bow->type == BOW && bow->race == item->race)
1325 { 1310 {
1326 SET_FLAG (mon, FLAG_READY_BOW); 1311 SET_FLAG (mon, FLAG_READY_BOW);
1327 LOG (llevMonster, "Found correct bow for arrows.\n"); 1312 LOG (llevMonster, "Found correct bow for arrows.\n");
1328 return; /* nothing more to do for arrows */ 1313 return; /* nothing more to do for arrows */
… …
1380 */ 1365 */
1381 SET_FLAG (mon, FLAG_READY_SKILL); 1366 SET_FLAG (mon, FLAG_READY_SKILL);
1382 return; 1367 return;
1383 } 1368 }
1384 1369
1385
1386 /* if we don't match one of the above types, return now. 1370 /* if we don't match one of the above types, return now.
1387 * can_apply_object will say that we can apply things like flesh, 1371 * can_apply_object will say that we can apply things like flesh,
1388 * bolts, and whatever else, because it only checks against the 1372 * bolts, and whatever else, because it only checks against the
1389 * body_info locations. 1373 * body_info locations.
1390 */ 1374 */
… …
1401 /* should only be applying this item, not unapplying it. 1385 /* should only be applying this item, not unapplying it.
1402 * also, ignore status of curse so they can take off old armour. 1386 * also, ignore status of curse so they can take off old armour.
1403 * monsters have some advantages after all. 1387 * monsters have some advantages after all.
1404 */ 1388 */
1405 manual_apply (mon, item, AP_APPLY | AP_IGNORE_CURSE); 1389 manual_apply (mon, item, AP_APPLY | AP_IGNORE_CURSE);
1406
1407 return;
1408} 1390}
1409 1391
1410void 1392void
1411npc_call_help (object *op) 1393npc_call_help (object *op)
1412{ 1394{
… …
1430 if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE)) 1412 if (QUERY_FLAG (npc, FLAG_ALIVE) && QUERY_FLAG (npc, FLAG_UNAGGRESSIVE))
1431 npc->enemy = op->enemy; 1413 npc->enemy = op->enemy;
1432 } 1414 }
1433} 1415}
1434 1416
1435
1436int 1417int
1437dist_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv) 1418dist_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
1438{ 1419{
1439
1440 if (can_hit (part, enemy, rv)) 1420 if (can_hit (part, enemy, rv))
1441 return dir; 1421 return dir;
1442 if (rv->distance < 10) 1422 if (rv->distance < 10)
1443 return absdir (dir + 4); 1423 return absdir (dir + 4);
1444 else if (rv->distance > 18) 1424 else if (rv->distance > 18)
1445 return dir; 1425 return dir;
1426
1446 return 0; 1427 return 0;
1447} 1428}
1448 1429
1449int 1430int
1450run_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv) 1431run_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
1451{ 1432{
1452
1453 if ((can_hit (part, enemy, rv) && ob->move_status < 20) || ob->move_status < 20) 1433 if ((can_hit (part, enemy, rv) && ob->move_status < 20) || ob->move_status < 20)
1454 { 1434 {
1455 ob->move_status++; 1435 ob->move_status++;
1456 return (dir); 1436 return (dir);
1457 } 1437 }
1458 else if (ob->move_status > 20) 1438 else if (ob->move_status > 20)
1459 ob->move_status = 0; 1439 ob->move_status = 0;
1440
1460 return absdir (dir + 4); 1441 return absdir (dir + 4);
1461} 1442}
1462 1443
1463int 1444int
1464hitrun_att (int dir, object *ob, object *enemy) 1445hitrun_att (int dir, object *ob, object *enemy)
… …
1467 return dir; 1448 return dir;
1468 else if (ob->move_status < 50) 1449 else if (ob->move_status < 50)
1469 return absdir (dir + 4); 1450 return absdir (dir + 4);
1470 else 1451 else
1471 ob->move_status = 0; 1452 ob->move_status = 0;
1453
1472 return absdir (dir + 4); 1454 return absdir (dir + 4);
1473} 1455}
1474 1456
1475int 1457int
1476wait_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv) 1458wait_att (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
… …
1485 return 0; 1467 return 0;
1486 else if (ob->move_status < 10) 1468 else if (ob->move_status < 10)
1487 return dir; 1469 return dir;
1488 else if (ob->move_status < 15) 1470 else if (ob->move_status < 15)
1489 return absdir (dir + 4); 1471 return absdir (dir + 4);
1472
1490 ob->move_status = 0; 1473 ob->move_status = 0;
1491 return 0; 1474 return 0;
1492} 1475}
1493 1476
1494int 1477int
… …
1502 * at least one map has this set, and whatever the map contains, the 1485 * at least one map has this set, and whatever the map contains, the
1503 * server should try to be resilant enough to avoid the problem 1486 * server should try to be resilant enough to avoid the problem
1504 */ 1487 */
1505 if (ob->stats.maxhp && (ob->stats.hp * 100) / ob->stats.maxhp < ob->run_away) 1488 if (ob->stats.maxhp && (ob->stats.hp * 100) / ob->stats.maxhp < ob->run_away)
1506 return absdir (dir + 4); 1489 return absdir (dir + 4);
1490
1507 return dist_att (dir, ob, enemy, part, rv); 1491 return dist_att (dir, ob, enemy, part, rv);
1508} 1492}
1509 1493
1510int 1494int
1511wait_att2 (int dir, object *ob, object *enemy, object *part, rv_vector * rv) 1495wait_att2 (int dir, object *ob, object *enemy, object *part, rv_vector * rv)
1512{ 1496{
1513 if (rv->distance < 9) 1497 if (rv->distance < 9)
1514 return absdir (dir + 4); 1498 return absdir (dir + 4);
1499
1515 return 0; 1500 return 0;
1516} 1501}
1517 1502
1518void 1503void
1519circ1_move (object *ob) 1504circ1_move (object *ob)
1520{ 1505{
1521 static int circle[12] = { 3, 3, 4, 5, 5, 6, 7, 7, 8, 1, 1, 2 }; 1506 static int circle[12] = { 3, 3, 4, 5, 5, 6, 7, 7, 8, 1, 1, 2 };
1507
1522 if (++ob->move_status > 11) 1508 if (++ob->move_status > 11)
1523 ob->move_status = 0; 1509 ob->move_status = 0;
1510
1524 if (!(move_object (ob, circle[ob->move_status]))) 1511 if (!(move_object (ob, circle[ob->move_status])))
1525 (void) move_object (ob, rndm (8) + 1); 1512 move_object (ob, rndm (8) + 1);
1526} 1513}
1527 1514
1528void 1515void
1529circ2_move (object *ob) 1516circ2_move (object *ob)
1530{ 1517{
1531 static int circle[20] = { 3, 3, 3, 4, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 1, 1, 1, 2, 2 }; 1518 static int circle[20] = { 3, 3, 3, 4, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 1, 1, 1, 2, 2 };
1519
1532 if (++ob->move_status > 19) 1520 if (++ob->move_status > 19)
1533 ob->move_status = 0; 1521 ob->move_status = 0;
1522
1534 if (!(move_object (ob, circle[ob->move_status]))) 1523 if (!(move_object (ob, circle[ob->move_status])))
1535 (void) move_object (ob, rndm (8) + 1); 1524 move_object (ob, rndm (8) + 1);
1536} 1525}
1537 1526
1538void 1527void
1539pace_movev (object *ob) 1528pace_movev (object *ob)
1540{ 1529{
1541 if (ob->move_status++ > 6) 1530 if (ob->move_status++ > 6)
1542 ob->move_status = 0; 1531 ob->move_status = 0;
1532
1543 if (ob->move_status < 4) 1533 if (ob->move_status < 4)
1544 (void) move_object (ob, 5); 1534 move_object (ob, 5);
1545 else 1535 else
1546 (void) move_object (ob, 1); 1536 move_object (ob, 1);
1547} 1537}
1548 1538
1549void 1539void
1550pace_moveh (object *ob) 1540pace_moveh (object *ob)
1551{ 1541{
1552 if (ob->move_status++ > 6) 1542 if (ob->move_status++ > 6)
1553 ob->move_status = 0; 1543 ob->move_status = 0;
1544
1554 if (ob->move_status < 4) 1545 if (ob->move_status < 4)
1555 (void) move_object (ob, 3); 1546 move_object (ob, 3);
1556 else 1547 else
1557 (void) move_object (ob, 7); 1548 move_object (ob, 7);
1558} 1549}
1559 1550
1560void 1551void
1561pace2_movev (object *ob) 1552pace2_movev (object *ob)
1562{ 1553{
1563 if (ob->move_status++ > 16) 1554 if (ob->move_status++ > 16)
1564 ob->move_status = 0; 1555 ob->move_status = 0;
1556
1565 if (ob->move_status < 6) 1557 if (ob->move_status < 6)
1566 (void) move_object (ob, 5); 1558 move_object (ob, 5);
1567 else if (ob->move_status < 8) 1559 else if (ob->move_status < 8)
1568 return; 1560 return;
1569 else if (ob->move_status < 13) 1561 else if (ob->move_status < 13)
1570 (void) move_object (ob, 1); 1562 move_object (ob, 1);
1571 else 1563 else
1572 return; 1564 return;
1573} 1565}
1574 1566
1575void 1567void
1576pace2_moveh (object *ob) 1568pace2_moveh (object *ob)
1577{ 1569{
1578 if (ob->move_status++ > 16) 1570 if (ob->move_status++ > 16)
1579 ob->move_status = 0; 1571 ob->move_status = 0;
1572
1580 if (ob->move_status < 6) 1573 if (ob->move_status < 6)
1581 (void) move_object (ob, 3); 1574 move_object (ob, 3);
1582 else if (ob->move_status < 8) 1575 else if (ob->move_status < 8)
1583 return; 1576 return;
1584 else if (ob->move_status < 13) 1577 else if (ob->move_status < 13)
1585 (void) move_object (ob, 7); 1578 move_object (ob, 7);
1586 else 1579 else
1587 return; 1580 return;
1588} 1581}
1589 1582
1590void 1583void
… …
1633 * monsters to throw things like chairs and other pieces of 1626 * monsters to throw things like chairs and other pieces of
1634 * furniture, even if they are not good throwable objects. 1627 * furniture, even if they are not good throwable objects.
1635 * Probably better to have the monster throw a throwable object 1628 * Probably better to have the monster throw a throwable object
1636 * first, then throw any non equipped weapon. 1629 * first, then throw any non equipped weapon.
1637 */ 1630 */
1638
1639object * 1631object *
1640find_mon_throw_ob (object *op) 1632find_mon_throw_ob (object *op)
1641{ 1633{
1642 object *tmp = NULL; 1634 object *tmp = NULL;
1643 1635
… …
1674 * properly. I also so odd code in place that checked for x distance 1666 * properly. I also so odd code in place that checked for x distance
1675 * OR y distance being within some range - that seemed wrong - both should 1667 * OR y distance being within some range - that seemed wrong - both should
1676 * be within the valid range. MSW 2001-08-05 1668 * be within the valid range. MSW 2001-08-05
1677 * Returns 0 if enemy can not be detected, 1 if it is detected 1669 * Returns 0 if enemy can not be detected, 1 if it is detected
1678 */ 1670 */
1679
1680int 1671int
1681can_detect_enemy (object *op, object *enemy, rv_vector * rv) 1672can_detect_enemy (object *op, object *enemy, rv_vector * rv)
1682{ 1673{
1683 int radius = MIN_MON_RADIUS, hide_discovery; 1674 int radius = MIN_MON_RADIUS, hide_discovery;
1684 1675
… …
1715 /* use this for invis also */ 1706 /* use this for invis also */
1716 hide_discovery = op->stats.Int / 5; 1707 hide_discovery = op->stats.Int / 5;
1717 1708
1718 /* Determine Detection radii */ 1709 /* Determine Detection radii */
1719 if (!enemy->hide) /* to detect non-hidden (eg dark/invis enemy) */ 1710 if (!enemy->hide) /* to detect non-hidden (eg dark/invis enemy) */
1720 radius = (op->stats.Wis / 5) + 1 > MIN_MON_RADIUS ? (op->stats.Wis / 5) + 1 : MIN_MON_RADIUS; 1711 radius = max (MIN_MON_RADIUS, op->stats.Wis / 5 + 1);
1721 else 1712 else
1722 { /* a level/INT/Dex adjustment for hiding */ 1713 { /* a level/INT/Dex adjustment for hiding */
1723 object *sk_hide;
1724 int bonus = (op->level / 2) + (op->stats.Int / 5); 1714 int bonus = op->level / 2 + op->stats.Int / 5;
1725 1715
1726 if (enemy->type == PLAYER) 1716 if (enemy->type == PLAYER)
1727 { 1717 {
1728 if ((sk_hide = find_skill_by_number (enemy, SK_HIDING))) 1718 if (object *sk_hide = find_skill_by_number (enemy, SK_HIDING))
1729 bonus -= sk_hide->level; 1719 bonus -= sk_hide->level;
1730 else 1720 else
1731 { 1721 {
1732 LOG (llevError, "can_detect_enemy() got hidden player w/o hiding skill!\n"); 1722 LOG (llevError, "can_detect_enemy() got hidden player w/o hiding skill!\n");
1733 make_visible (enemy); 1723 make_visible (enemy);
… …
1742 } /* else creature has modifiers for hiding */ 1732 } /* else creature has modifiers for hiding */
1743 1733
1744 /* Radii stealth adjustment. Only if you are stealthy 1734 /* Radii stealth adjustment. Only if you are stealthy
1745 * will you be able to sneak up closer to creatures */ 1735 * will you be able to sneak up closer to creatures */
1746 if (QUERY_FLAG (enemy, FLAG_STEALTH)) 1736 if (QUERY_FLAG (enemy, FLAG_STEALTH))
1747 radius = radius / 2, hide_discovery = hide_discovery / 3; 1737 {
1738 radius /= 2;
1739 hide_discovery /= 3;
1740 }
1748 1741
1749 /* Radii adjustment for enemy standing in the dark */ 1742 /* Radii adjustment for enemy standing in the dark */
1750 if (op->map->darkness > 0 && !stand_in_light (enemy)) 1743 if (op->map->darkness > 0 && !stand_in_light (enemy))
1751 { 1744 {
1752 /* on dark maps body heat can help indicate location with infravision 1745 /* on dark maps body heat can help indicate location with infravision
… …
1770 * may have for their map - in that way, creatures at the edge will 1763 * may have for their map - in that way, creatures at the edge will
1771 * do something. Note that the distance field in the 1764 * do something. Note that the distance field in the
1772 * vector is real distance, so in theory this should be 18 to 1765 * vector is real distance, so in theory this should be 18 to
1773 * find that. 1766 * find that.
1774 */ 1767 */
1775 if (radius > 13) 1768 // note that the above reasoning was utter bullshit even at the time it was written
1776 radius = 13; 1769 // we use 25, lets see if we have the cpu time for it
1770 radius = min (25, radius);
1777 1771
1778 /* Enemy in range! Now test for detection */ 1772 /* Enemy in range! Now test for detection */
1779 if ((int) rv->distance <= radius) 1773 if (rv->distance <= radius)
1780 { 1774 {
1781 /* ah, we are within range, detected? take cases */ 1775 /* ah, we are within range, detected? take cases */
1782 if (!enemy->invisible) /* enemy in dark squares... are seen! */ 1776 if (!enemy->invisible) /* enemy in dark squares... are seen! */
1783 return 1; 1777 return 1;
1784 1778
1785 /* hidden or low-quality invisible */ 1779 /* hidden or low-quality invisible */
1786 if (enemy->hide && (rv->distance <= 1) && (rndm (100) <= hide_discovery)) 1780 if (enemy->hide && rv->distance <= 1 && rndm (100) <= hide_discovery)
1787 { 1781 {
1788 make_visible (enemy); 1782 make_visible (enemy);
1783
1789 /* inform players of new status */ 1784 /* inform players of new status */
1790 if (enemy->type == PLAYER && player_can_view (enemy, op)) 1785 if (enemy->type == PLAYER && player_can_view (enemy, op))
1791 new_draw_info_format (NDI_UNIQUE, 0, enemy, "You are discovered by %s!", &op->name); 1786 new_draw_info_format (NDI_UNIQUE, 0, enemy, "You are discovered by %s!", &op->name);
1787
1792 return 1; /* detected enemy */ 1788 return 1; /* detected enemy */
1793 } 1789 }
1794 else if (enemy->invisible) 1790 else if (enemy->invisible)
1795 { 1791 {
1796 /* Change this around - instead of negating the invisible, just 1792 /* Change this around - instead of negating the invisible, just
1797 * return true so that the mosnter that managed to detect you can 1793 * return true so that the monster that managed to detect you can
1798 * do something to you. Decreasing the duration of invisible 1794 * do something to you. Decreasing the duration of invisible
1799 * doesn't make a lot of sense IMO, as a bunch of stupid creatures 1795 * doesn't make a lot of sense IMO, as a bunch of stupid creatures
1800 * can then basically negate the spell. The spell isn't negated - 1796 * can then basically negate the spell. The spell isn't negated -
1801 * they just know where you are! 1797 * they just know where you are!
1802 */ 1798 */
1803 if ((rndm (50)) <= hide_discovery) 1799 if (rndm (50) <= hide_discovery)
1804 { 1800 {
1805 if (enemy->type == PLAYER) 1801 if (enemy->type == PLAYER)
1806 {
1807 new_draw_info_format (NDI_UNIQUE, 0, enemy, "You see %s noticing your position.", query_name (op)); 1802 new_draw_info_format (NDI_UNIQUE, 0, enemy, "You see %s noticing your position.", query_name (op));
1808 } 1803
1809 return 1; 1804 return 1;
1810 } 1805 }
1811 } 1806 }
1812 } /* within range */ 1807 } /* within range */
1813 1808
… …
1818/* determine if op stands in a lighted square. This is not a very 1813/* determine if op stands in a lighted square. This is not a very
1819 * intellegent algorithm. For one thing, we ignore los here, SO it 1814 * intellegent algorithm. For one thing, we ignore los here, SO it
1820 * is possible for a bright light to illuminate a player on the 1815 * is possible for a bright light to illuminate a player on the
1821 * other side of a wall (!). 1816 * other side of a wall (!).
1822 */ 1817 */
1823
1824int 1818int
1825stand_in_light (object *op) 1819stand_in_light (object *op)
1826{ 1820{
1827 sint16 nx, ny;
1828 maptile *m;
1829
1830
1831 if (!op) 1821 if (!op)
1832 return 0; 1822 return 0;
1823
1833 if (op->glow_radius > 0) 1824 if (op->glow_radius > 0)
1834 return 1; 1825 return 1;
1835 1826
1836 if (op->map) 1827 if (op->map)
1837 { 1828 {
1838 int x, y, x1, y1;
1839
1840
1841
1842 /* Check the spaces with the max light radius to see if any of them 1829 /* Check the spaces with the max light radius to see if any of them
1843 * have lights, and if any of them light the player enough, then return 1. 1830 * have lights, and if any of them light the player enough, then return 1.
1844 */ 1831 */
1845 for (x = op->x - MAX_LIGHT_RADII; x <= op->x + MAX_LIGHT_RADII; x++) 1832 for (int x = op->x - MAX_LIGHT_RADII; x <= op->x + MAX_LIGHT_RADII; x++)
1846 { 1833 {
1847 for (y = op->y - MAX_LIGHT_RADII; y <= op->y + MAX_LIGHT_RADII; y++) 1834 for (int y = op->y - MAX_LIGHT_RADII; y <= op->y + MAX_LIGHT_RADII; y++)
1848 { 1835 {
1849 m = op->map; 1836 maptile *m = op->map;
1850 nx = x; 1837 sint16 nx = x;
1851 ny = y; 1838 sint16 ny = y;
1852 1839
1853 if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP) 1840 if (xy_normalise (m, nx, ny))
1854 continue; 1841 if (idistance (x - op->x, y - op->y) < m->at (nx, ny).light)
1855
1856 x1 = abs (x - op->x) * abs (x - op->x);
1857 y1 = abs (y - op->y) * abs (y - op->y);
1858 if (isqrt (x1 + y1) < GET_MAP_LIGHT (m, nx, ny))
1859 return 1; 1842 return 1;
1860 } 1843 }
1861 } 1844 }
1862 } 1845 }
1846
1863 return 0; 1847 return 0;
1864} 1848}
1865
1866 1849
1867/* assuming no walls/barriers, lets check to see if its *possible* 1850/* assuming no walls/barriers, lets check to see if its *possible*
1868 * to see an enemy. Note, "detection" is different from "seeing". 1851 * to see an enemy. Note, "detection" is different from "seeing".
1869 * See can_detect_enemy() for more details. -b.t. 1852 * See can_detect_enemy() for more details. -b.t.
1870 * return 0 if can't be seen, 1 if can be 1853 * return 0 if can't be seen, 1 if can be
1871 */ 1854 */
1872
1873int 1855int
1874can_see_enemy (object *op, object *enemy) 1856can_see_enemy (object *op, object *enemy)
1875{ 1857{
1876 object *looker = op->head ? op->head : op; 1858 object *looker = op->head ? op->head : op;
1877 1859

Diff Legend

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