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

Comparing deliantra/server/server/skill_util.C (file contents):
Revision 1.34 by root, Mon Apr 30 05:54:14 2007 UTC vs.
Revision 1.47 by root, Sun May 13 19:56:57 2007 UTC

1/* 1/*
2 * CrossFire, A Multiplayer game for X-windows 2 * CrossFire, A Multiplayer game
3 * 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team 4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
5 * Copryight (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copryight (C) 2002 Mark Wedel & Crossfire Development Team
6 * Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (C) 1992 Frank Tore Johansen
7 * 7 *
… …
115 * tool, this code will equip it. 115 * tool, this code will equip it.
116 */ 116 */
117object * 117object *
118find_skill_by_name (object *who, const char *name) 118find_skill_by_name (object *who, const char *name)
119{ 119{
120 object *skill = NULL, *skill_tool = NULL, *tmp;
121
122 if (!name) 120 if (!name)
123 return NULL; 121 return 0;
122
123 object *skill = 0, *skill_tool = 0;
124 124
125 /* We make sure the length of the string in the object is greater 125 /* We make sure the length of the string in the object is greater
126 * in length than the passed string. Eg, if we have a skill called 126 * in length than the passed string. Eg, if we have a skill called
127 * 'hi', we don't want to match if the user passed 'high' 127 * 'hi', we don't want to match if the user passed 'high'
128 */ 128 */
129 for (tmp = who->inv; tmp != NULL; tmp = tmp->below) 129 for (object *tmp = who->inv; tmp; tmp = tmp->below)
130 { 130 {
131 if (tmp->type == SKILL && !strncasecmp (name, tmp->skill, strlen (name)) && (size_t) strlen (tmp->skill) >= strlen (name)) 131 if (tmp->type == SKILL && !strncasecmp (name, tmp->skill, strlen (name)) && strlen (tmp->skill) >= strlen (name))
132 skill = tmp; 132 skill = tmp;
133 133
134 /* Try to find appropriate skilltool. If the player has one already 134 /* Try to find appropriate skilltool. If the player has one already
135 * applied, we try to keep using that one. 135 * applied, we try to keep using that one.
136 */ 136 */
137 else if (tmp->type == SKILL_TOOL && !strncasecmp (name, tmp->skill, strlen (name)) && (size_t) strlen (tmp->skill) >= strlen (name)) 137 else if (tmp->type == SKILL_TOOL && !strncasecmp (name, tmp->skill, strlen (name)) && strlen (tmp->skill) >= strlen (name))
138 { 138 {
139 if (QUERY_FLAG (tmp, FLAG_APPLIED)) 139 if (QUERY_FLAG (tmp, FLAG_APPLIED))
140 skill_tool = tmp; 140 skill_tool = tmp;
141 else if (!skill_tool || !QUERY_FLAG (skill_tool, FLAG_APPLIED)) 141 else if (!skill_tool || !QUERY_FLAG (skill_tool, FLAG_APPLIED))
142 skill_tool = tmp; 142 skill_tool = tmp;
143 } 143 }
144 } 144 }
145
145 /* If this is a skill that can be used without a tool, return it */ 146 /* If this is a skill that can be used without a tool, return it */
146 if (skill && QUERY_FLAG (skill, FLAG_CAN_USE_SKILL)) 147 if (skill && QUERY_FLAG (skill, FLAG_CAN_USE_SKILL))
147 return skill; 148 return skill;
148 149
149 /* Player has a tool to use the skill. IF not applied, apply it - 150 /* Player has a tool to use the skill. If not applied, apply it -
150 * if not successful, return null. If they do have the skill tool 151 * if not successful, return null. If they do have the skill tool
151 * but not the skill itself, give it to them. 152 * but not the skill itself, give it to them.
152 */ 153 */
153 if (skill_tool) 154 if (skill_tool)
154 { 155 {
155 if (!QUERY_FLAG (skill_tool, FLAG_APPLIED)) 156 if (!QUERY_FLAG (skill_tool, FLAG_APPLIED))
156 {
157 if (apply_special (who, skill_tool, 0)) 157 if (apply_special (who, skill_tool, 0))
158 return NULL; 158 return 0;
159 }
160 159
161 if (!skill) 160 if (!skill)
162 { 161 {
163 skill = give_skill_by_name (who, skill_tool->skill); 162 skill = give_skill_by_name (who, skill_tool->skill);
164 link_player_skills (who); 163 link_player_skills (who);
165 } 164 }
166 165
167 return skill; 166 return skill;
168 } 167 }
169 168
170 return NULL; 169 return 0;
171} 170}
172
173 171
174/* This returns the skill pointer of the given name (the 172/* This returns the skill pointer of the given name (the
175 * one that accumlates exp, has the level, etc). 173 * one that accumlates exp, has the level, etc).
176 * 174 *
177 * It is presumed that the player will be needing to actually 175 * It is presumed that the player will be needing to actually
… …
183 * this replaces find_skill. 181 * this replaces find_skill.
184 */ 182 */
185object * 183object *
186find_skill_by_number (object *who, int skillno) 184find_skill_by_number (object *who, int skillno)
187{ 185{
186 if (!IN_RANGE_EXC (skillno, 1, NUM_SKILLS))
187 return 0;
188
188 object *skill = NULL, *skill_tool = NULL, *tmp; 189 object *skill = NULL, *skill_tool = NULL;
189 190
190 if (skillno < 1 || skillno >= NUM_SKILLS)
191 return NULL;
192
193 for (tmp = who->inv; tmp != NULL; tmp = tmp->below) 191 for (object *tmp = who->inv; tmp; tmp = tmp->below)
194 { 192 {
195 if (tmp->type == SKILL && tmp->subtype == skillno) 193 if (tmp->type == SKILL && tmp->subtype == skillno)
196 skill = tmp; 194 skill = tmp;
197 195
198 /* Try to find appropriate skilltool. If the player has one already 196 /* Try to find appropriate skilltool. If the player has one already
… …
204 skill_tool = tmp; 202 skill_tool = tmp;
205 else if (!skill_tool || !QUERY_FLAG (skill_tool, FLAG_APPLIED)) 203 else if (!skill_tool || !QUERY_FLAG (skill_tool, FLAG_APPLIED))
206 skill_tool = tmp; 204 skill_tool = tmp;
207 } 205 }
208 } 206 }
207
209 /* If this is a skill that can be used without a tool, return it */ 208 /* If this is a skill that can be used without a tool, return it */
210 if (skill && QUERY_FLAG (skill, FLAG_CAN_USE_SKILL)) 209 if (skill && QUERY_FLAG (skill, FLAG_CAN_USE_SKILL))
211 return skill; 210 return skill;
212 211
213 /* Player has a tool to use the skill. IF not applied, apply it - 212 /* Player has a tool to use the skill. If not applied, apply it -
214 * if not successful, return null. If they do have the skill tool 213 * if not successful, return null. If they do have the skill tool
215 * but not the skill itself, give it to them. 214 * but not the skill itself, give it to them.
216 */ 215 */
217 if (skill_tool) 216 if (skill_tool)
218 { 217 {
219 if (!QUERY_FLAG (skill_tool, FLAG_APPLIED)) 218 if (!QUERY_FLAG (skill_tool, FLAG_APPLIED))
… …
235} 234}
236 235
237/* This changes the objects skill to new_skill. 236/* This changes the objects skill to new_skill.
238 * note that this function doesn't always need to get used - 237 * note that this function doesn't always need to get used -
239 * you can now add skill exp to the player without the chosen_skill being 238 * you can now add skill exp to the player without the chosen_skill being
240 * set. This function is of most interest to players to update 239 * set. This function is of most interest to players to update
241 * the various range information. 240 * the various range information.
242 * if new_skill is null, this just unapplies the skill.
243 * flag has the current meaning:
244 * 0x1: If set, don't update the range pointer. This is useful when we
245 * need to ready a new skill, but don't want to clobber range.
246 * return 1 on success, 0 on error 241 * return 1 on success, 0 on error
247 */ 242 */
248int 243int
249change_skill (object *who, object *new_skill, int flag) 244change_skill (object *who, object *new_skill, int flag)
250{ 245{
251 int old_range;
252
253 if (who->type != PLAYER) 246 if (who->type != PLAYER)
254 return 0; 247 return 0;
255 248
256 player *pl = who->contr; 249#if 0
257 250 // optimise this supposedly common case
258 if (pl->ranged_skill && pl->ranged_skill == new_skill) 251 if (new_skill == who->chosen_skill)
259 return 1; 252 return 1;
253#endif
260 254
261 if (!new_skill) 255 if (!new_skill)
262 { 256 {
263 if (pl->ranged_skill) 257 LOG (llevError | logBacktrace, "change_skill called on %s with NULL skill\n",
264 apply_special (who, pl->ranged_skill, AP_UNAPPLY); 258 who->debug_desc ());
265
266 /* Only goal in this case was to unapply a skill */
267 return 0; 259 return 0;
268 } 260 }
269 261
270 // move skill to front, so it will be preferred next time 262 // the skill could be readied already because it is used by a weapon.
271 new_skill->remove (); 263 who->change_weapon (0);
272 who->insert (new_skill); 264 new_skill->inv_splay ();
273 265
274 if (apply_special (who, new_skill, AP_APPLY)) 266 if (apply_special (who, new_skill, AP_APPLY))
275 return 0; 267 return 0;
276 268
277 return 1; 269 return 1;
… …
285{ 277{
286 who->chosen_skill = 0; 278 who->chosen_skill = 0;
287 CLEAR_FLAG (who, FLAG_READY_SKILL); 279 CLEAR_FLAG (who, FLAG_READY_SKILL);
288 280
289 if (who->type == PLAYER) 281 if (who->type == PLAYER)
290 {
291 if (who->contr->ranged_skill && who->contr->ranged_skill->type == SKILL) 282 if (who->contr->ranged_ob && who->contr->ranged_ob->type == SKILL)
292 {
293 who->contr->ranged_skill = 0;
294 who->contr->ranged_ob = 0; 283 who->contr->ranged_ob = 0;
295 }
296 }
297} 284}
298 285
299/* do_skill() - Main skills use function-similar in scope to cast_spell(). 286/* do_skill() - Main skills use function-similar in scope to cast_spell().
300 * We handle all requests for skill use outside of some combat here. 287 * We handle all requests for skill use outside of some combat here.
301 * We require a separate routine outside of fire() so as to allow monsters 288 * We require a separate routine outside of fire() so as to allow monsters
… …
309int 296int
310do_skill (object *op, object *part, object *skill, int dir, const char *string) 297do_skill (object *op, object *part, object *skill, int dir, const char *string)
311{ 298{
312 int success = 0, exp = 0; 299 int success = 0, exp = 0;
313 int did_alc = 0; 300 int did_alc = 0;
314 object *tmp, *next;
315 301
316 if (!skill) 302 if (!skill)
317 return 0; 303 return 0;
318 304
319 /* The code below presumes that the skill points to the object that 305 /* The code below presumes that the skill points to the object that
… …
321 * go and try to find the actual real skill pointer, and if the 307 * go and try to find the actual real skill pointer, and if the
322 * the player doesn't have a bucket for that, create one. 308 * the player doesn't have a bucket for that, create one.
323 */ 309 */
324 if (skill->type != SKILL && op->type == PLAYER) 310 if (skill->type != SKILL && op->type == PLAYER)
325 { 311 {
326 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 312 for (object *tmp = op->inv; tmp; tmp = tmp->below)
327 if (tmp->type == SKILL && tmp->skill == skill->skill) 313 if (tmp->type == SKILL && tmp->skill == skill->skill)
328 break; 314 {
315 skill = tmp;
316 goto found;
317 }
329 318
330 if (!tmp)
331 tmp = give_skill_by_name (op, skill->skill); 319 skill = give_skill_by_name (op, skill->skill);
332 320found: ;
333 skill = tmp;
334 } 321 }
335 322
336 // skill, by_whom, on_which_object, which direction, skill_argument 323 // skill, by_whom, on_which_object, which direction, skill_argument
337 if (INVOKE_OBJECT (USE_SKILL, skill, ARG_OBJECT (op), ARG_OBJECT (part), ARG_INT (dir), ARG_STRING (string))) 324 if (INVOKE_OBJECT (USE_SKILL, skill, ARG_OBJECT (op), ARG_OBJECT (part), ARG_INT (dir), ARG_STRING (string)))
338 return 0; 325 return 0;
… …
443 case SK_LITERACY: 430 case SK_LITERACY:
444 case SK_WOODSMAN: 431 case SK_WOODSMAN:
445 /* first, we try to find a cauldron, and do the alchemy thing. 432 /* first, we try to find a cauldron, and do the alchemy thing.
446 * failing that, we go and identify stuff. 433 * failing that, we go and identify stuff.
447 */ 434 */
448 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = next) 435 for (object *next, *tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = next)
449 { 436 {
450 next = tmp->above; 437 next = tmp->above;
451 438
452 if (QUERY_FLAG (tmp, FLAG_IS_CAULDRON)) 439 if (QUERY_FLAG (tmp, FLAG_IS_CAULDRON))
453 { 440 {
… …
514 * If certain skills should take more/less time, that should be 501 * If certain skills should take more/less time, that should be
515 * in the code for the skill itself. 502 * in the code for the skill itself.
516 */ 503 */
517 504
518 if (op->type == PLAYER) 505 if (op->type == PLAYER)
519 op->speed_left -= 1.0; 506 op->speed_left -= 1.f;
520 507
521 /* this is a good place to add experience for successfull use of skills. 508 /* this is a good place to add experience for successfull use of skills.
522 * Note that add_exp() will figure out player/monster experience 509 * Note that add_exp() will figure out player/monster experience
523 * gain problems. 510 * gain problems.
524 */ 511 */
… …
695 link_player_skills (pl); 682 link_player_skills (pl);
696 return 1; 683 return 1;
697} 684}
698 685
699/* Gives a percentage clipped to 0% -> 100% of a/b. */ 686/* Gives a percentage clipped to 0% -> 100% of a/b. */
700
701/* Probably belongs in some global utils-type file? */ 687/* Probably belongs in some global utils-type file? */
702static int 688static int
703clipped_percent (sint64 a, sint64 b) 689clipped_percent (sint64 a, sint64 b)
704{ 690{
705 int rv; 691 int rv;
… …
798 * direction that the user is facing. Returns false if we are unable to 784 * direction that the user is facing. Returns false if we are unable to
799 * change to the requested skill, or were unable to use the skill properly. 785 * change to the requested skill, or were unable to use the skill properly.
800 * This is tricky because skills can have spaces. We basically roll 786 * This is tricky because skills can have spaces. We basically roll
801 * our own find_skill_by_name so we can try to do better string matching. 787 * our own find_skill_by_name so we can try to do better string matching.
802 */ 788 */
803
804int 789int
805use_skill (object *op, const char *string) 790use_skill (object *op, const char *string)
806{ 791{
807 object *skop; 792 object *skop;
808 size_t len; 793 size_t len;
… …
892 * is readied either then try to find a skill for the player to use. 877 * is readied either then try to find a skill for the player to use.
893 * it is presumed that if skill is set, it is a valid attack skill (eg, 878 * it is presumed that if skill is set, it is a valid attack skill (eg,
894 * the caller should have set it appropriately). We still want to pass 879 * the caller should have set it appropriately). We still want to pass
895 * through that code if skill is set to change to the skill. 880 * through that code if skill is set to change to the skill.
896 */ 881 */
897 if (op->type == PLAYER) 882 if (player *pl = op->contr)
898 { 883 {
899 if (!QUERY_FLAG (op, FLAG_READY_WEAPON)) 884 if (!pl->combat_ob)
900 { 885 {
901 if (!skill) 886 if (QUERY_FLAG (op, FLAG_READY_WEAPON))
902 { 887 {
903 /* See if the players chosen skill is a combat skill, and use 888 for (tmp = op->inv; tmp; tmp = tmp->below)
904 * it if appropriate. 889 if (tmp->type == WEAPON && QUERY_FLAG (tmp, FLAG_APPLIED))
905 */ 890 break;
906 if (op->chosen_skill && hth_skill_p (op->chosen_skill)) 891
907 skill = op->chosen_skill; 892 if (!tmp)
908 else
909 { 893 {
910 skill = find_player_hth_skill (op); 894 LOG (llevError, "Could not find applied weapon on %s\n", &op->name);
895 return 0;
896 }
911 897
898 change_skill (op, find_skill_by_name (op, tmp->skill), 1);
899 }
900 else
901 {
912 if (!skill) 902 if (!skill)
903 {
904 /* See if the players chosen skill is a combat skill, and use
905 * it if appropriate.
906 */
907 if (op->chosen_skill && hth_skill_p (op->chosen_skill))
908 skill = op->chosen_skill;
909 else
913 { 910 {
911 skill = find_player_hth_skill (op);
912
913 if (!skill)
914 {
914 new_draw_info (NDI_BLACK, 0, op, "You have no unarmed combat skills!"); 915 new_draw_info (NDI_BLACK, 0, op, "You have no unarmed combat skills!");
915 return 0; 916 return 0;
917 }
916 } 918 }
917 } 919 }
920
921 /* now try to ready the new skill */
922 if (!change_skill (op, skill, 0))
923 { /* oh oh, trouble! */
924 new_draw_info_format (NDI_UNIQUE, 0, op, "Couldn't change to skill %s", &skill->name);
925 return 0;
926 }
918 } 927 }
919 928
920 /* now try to ready the new skill */ 929 if (!pl->combat_ob)
921 if (!change_skill (op, skill, 0)) 930 {
922 { /* oh oh, trouble! */ 931 LOG (llevError, "Could not find anything to attack on %s\n", &op->name);
923 new_draw_info_format (NDI_UNIQUE, 0, tmp, "Couldn't change to skill %s", &skill->name);
924 return 0; 932 return 0;
925 } 933 }
926 } 934 }
927 else 935
936 if (!op->change_weapon (pl->combat_ob))
937 return 0;
938
939 /* lose invisiblity/hiding status for running attacks */
940 if (pl->tmp_invis)
928 { 941 {
929 /* Seen some crashes below where current_weapon is not set, 942 pl->tmp_invis = 0;
930 * even though the flag says it is. So if current weapon isn't set, 943 op->invisible = 0;
931 * do some work in trying to find the object to use. 944 op->hide = 0;
932 */ 945 update_object (op, UP_OBJ_CHANGE);
933 if (!op->current_weapon)
934 {
935 object *tmp;
936
937 LOG (llevError, "Player %s does not have current weapon set but flag_ready_weapon is set\n", &op->name);
938 for (tmp = op->inv; tmp; tmp = tmp->below)
939 if (tmp->type == WEAPON && QUERY_FLAG (tmp, FLAG_APPLIED))
940 break;
941
942 if (!tmp)
943 {
944 LOG (llevError, "Could not find applied weapon on %s\n", &op->name);
945 op->current_weapon = NULL;
946 return 0;
947 }
948 else
949 op->current_weapon = tmp;
950 }
951
952 change_skill (op, find_skill_by_name (op, op->current_weapon->skill), 1);
953 } 946 }
954 }
955
956 /* lose invisiblity/hiding status for running attacks */
957
958 if (op->type == PLAYER && op->contr->tmp_invis)
959 {
960 op->contr->tmp_invis = 0;
961 op->invisible = 0;
962 op->hide = 0;
963 update_object (op, UP_OBJ_CHANGE);
964 } 947 }
965 948
966 int success = attack_ob (tmp, op); 949 int success = attack_ob (tmp, op);
967 950
968 /* print appropriate messages to the player */ 951 /* print appropriate messages to the player */
… …
1039 } 1022 }
1040 1023
1041 return do_skill_attack (tmp, pl, string, skill); 1024 return do_skill_attack (tmp, pl, string, skill);
1042} 1025}
1043 1026
1044
1045/* attack_hth() - this handles all hand-to-hand attacks -b.t. */ 1027/* attack_hth() - this handles all hand-to-hand attacks -b.t. */
1046 1028
1047/* July 5, 1995 - I broke up attack_hth() into 2 parts. In the first 1029/* July 5, 1995 - I broke up attack_hth() into 2 parts. In the first
1048 * (attack_hth) we check for weapon use, etc in the second (the new 1030 * (attack_hth) we check for weapon use, etc in the second (the new
1049 * function skill_attack() we actually attack. 1031 * function skill_attack() we actually attack.
1050 */ 1032 */
1051
1052static int 1033static int
1053attack_hth (object *pl, int dir, const char *string, object *skill) 1034attack_hth (object *pl, int dir, const char *string, object *skill)
1054{ 1035{
1055 object *enemy = NULL, *weapon; 1036 object *enemy = NULL, *weapon;
1056 1037
… …
1065 if (pl->type == PLAYER) 1046 if (pl->type == PLAYER)
1066 { 1047 {
1067 new_draw_info (NDI_UNIQUE, 0, pl, "You unwield your weapon in order to attack."); 1048 new_draw_info (NDI_UNIQUE, 0, pl, "You unwield your weapon in order to attack.");
1068 esrv_update_item (UPD_FLAGS, pl, weapon); 1049 esrv_update_item (UPD_FLAGS, pl, weapon);
1069 } 1050 }
1051
1070 break; 1052 break;
1071 } 1053 }
1072 } 1054 }
1073 1055
1074 return skill_attack (enemy, pl, dir, string, skill); 1056 return skill_attack (enemy, pl, dir, string, skill);

Diff Legend

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