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

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.29 by root, Mon Jan 29 16:11:48 2007 UTC vs.
Revision 1.53 by root, Tue Apr 22 07:01:47 2008 UTC

1/* 1/*
2 * CrossFire, A Multiplayer game for X-windows 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team 4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (C) 2002-2003 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002-2003,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 * 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 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 <support@deliantra.net>
23 */ 22 */
24 23
25/* This file contains all the spell attack code. Grouping this code 24/* This file contains all the spell attack code. Grouping this code
26 * together should hopefully make it easier to find the relevent bits 25 * together should hopefully make it easier to find the relevent bits
27 * of code 26 * of code
… …
145 144
146 /* reduce chances of subsequent forking */ 145 /* reduce chances of subsequent forking */
147 new_bolt->stats.Dex -= 10; 146 new_bolt->stats.Dex -= 10;
148 tmp->stats.Dex -= 10; /* less forks from main bolt too */ 147 tmp->stats.Dex -= 10; /* less forks from main bolt too */
149 new_bolt->stats.Con += 25 * new_dir; /* adjust the left bias */ 148 new_bolt->stats.Con += 25 * new_dir; /* adjust the left bias */
150 new_bolt->speed_left = -0.1; 149 new_bolt->speed_left = -0.1f;
151 new_bolt->direction = t_dir; 150 new_bolt->direction = t_dir;
152 new_bolt->duration++; 151 new_bolt->duration++;
153 new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */ 152 new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */
154 new_bolt->stats.dam++; 153 new_bolt->stats.dam++;
155 tmp->stats.dam /= 2; /* reduce father bolt damage */ 154 tmp->stats.dam /= 2; /* reduce father bolt damage */
… …
163 */ 162 */
164 163
165void 164void
166move_bolt (object *op) 165move_bolt (object *op)
167{ 166{
168 object *tmp;
169 int mflags; 167 int mflags;
170 sint16 x, y; 168 sint16 x, y;
171 maptile *m; 169 maptile *m;
172 170
173 if (--op->duration < 0) 171 if (--op->duration < 0)
… …
246 else 244 else
247 { /* Create a copy of this object and put it ahead */ 245 { /* Create a copy of this object and put it ahead */
248 object *tmp = op->clone (); 246 object *tmp = op->clone ();
249 247
250 m->insert (tmp, x, y, op); 248 m->insert (tmp, x, y, op);
251 tmp->speed_left = -0.1; 249 tmp->speed_left = -0.1f;
252 /* To make up for the decrease at the top of the function */ 250 /* To make up for the decrease at the top of the function */
253 tmp->duration++; 251 tmp->duration++;
254 252
255 /* New forking code. Possibly create forks of this object 253 /* New forking code. Possibly create forks of this object
256 * going off in other directions. 254 * going off in other directions.
… …
338 move_bolt (tmp); 336 move_bolt (tmp);
339 337
340 return 1; 338 return 1;
341} 339}
342 340
343
344
345/*************************************************************************** 341/***************************************************************************
346 * 342 *
347 * BULLET/BALL CODE 343 * BULLET/BALL CODE
348 * 344 *
349 ***************************************************************************/ 345 ***************************************************************************/
350 346
351/* expands an explosion. op is a piece of the 347/* expands an explosion. op is a piece of the
352 * explosion - this expans it in the different directions. 348 * explosion - this expands it in the different directions.
353 * At least that is what I think this does. 349 * At least that is what I think this does.
354 */ 350 */
355void 351void
356explosion (object *op) 352explosion (object *op)
357{ 353{
… …
381 if (ok_to_put_more (op->map, dx, dy, op, op->attacktype)) 377 if (ok_to_put_more (op->map, dx, dy, op, op->attacktype))
382 { 378 {
383 object *tmp = op->clone (); 379 object *tmp = op->clone ();
384 380
385 tmp->state = 0; 381 tmp->state = 0;
386 tmp->speed_left = -0.21; 382 tmp->speed_left = -0.21f;
387 tmp->range--; 383 tmp->range--;
388 tmp->value = 0; 384 tmp->value = 0;
389 385
390 m->insert (tmp, dx, dy, op); 386 m->insert (tmp, dx, dy, op);
391 } 387 }
392 } 388 }
393 } 389 }
394} 390}
395
396 391
397/* Causes an object to explode, eg, a firebullet, 392/* Causes an object to explode, eg, a firebullet,
398 * poison cloud ball, etc. op is the object to 393 * poison cloud ball, etc. op is the object to
399 * explode. 394 * explode.
400 */ 395 */
… …
410 return; 405 return;
411 } 406 }
412 407
413 if (op->env) 408 if (op->env)
414 { 409 {
415 object *env = object_get_env_recursive (op); 410 object *env = op->outer_env ();
411
416 if (env->map == NULL || out_of_map (env->map, env->x, env->y)) 412 if (!env->map || out_of_map (env->map, env->x, env->y))
417 { 413 {
418 LOG (llevError, "BUG: explode_bullet(): env out of map\n"); 414 LOG (llevError, "BUG: explode_bullet(): env out of map\n");
419 op->destroy (); 415 op->destroy ();
420 return; 416 return;
421 } 417 }
… …
488 484
489 /* Prevent recursion */ 485 /* Prevent recursion */
490 op->move_on = 0; 486 op->move_on = 0;
491 487
492 tmp->insert_at (op, op); 488 tmp->insert_at (op, op);
489 tmp->play_sound (tmp->sound);
490
493 /* remove the firebullet */ 491 /* remove the firebullet */
494 op->destroy (); 492 op->destroy ();
495} 493}
496 494
497/* checks to see what op should do, given the space it is on 495/* checks to see what op should do, given the space it is on
… …
519 517
520 /* If nothing alive on this space, no reason to do anything further */ 518 /* If nothing alive on this space, no reason to do anything further */
521 if (!(mflags & P_IS_ALIVE)) 519 if (!(mflags & P_IS_ALIVE))
522 return; 520 return;
523 521
524 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 522 for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
525 { 523 {
526 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 524 if (QUERY_FLAG (tmp, FLAG_ALIVE))
527 { 525 {
528 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1); 526 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
529 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0) 527 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
… …
605 } 603 }
606 else 604 else
607 check_bullet (op); 605 check_bullet (op);
608} 606}
609 607
610
611
612
613/* fire_bullet 608/* fire_bullet
614 * object op (cast from caster) files a bolt in dir. 609 * object op (cast from caster) files a bolt in dir.
615 * spob is the spell object for the bolt. 610 * spob is the spell object for the bolt.
616 * we remove the magic flag - that can be derived from 611 * we remove the magic flag - that can be derived from
617 * spob->attacktype. 612 * spob->attacktype.
618 * This function sets up the appropriate owner and skill 613 * This function sets up the appropriate owner and skill
619 * pointers. 614 * pointers.
620 */ 615 */
621
622int 616int
623fire_bullet (object *op, object *caster, int dir, object *spob) 617fire_bullet (object *op, object *caster, int dir, object *spob)
624{ 618{
625 object *tmp = NULL; 619 object *tmp = NULL;
626 int mflags; 620 int mflags;
… …
684 check_bullet (tmp); 678 check_bullet (tmp);
685 679
686 return 1; 680 return 1;
687} 681}
688 682
689
690
691
692/***************************************************************************** 683/*****************************************************************************
693 * 684 *
694 * CONE RELATED FUNCTIONS 685 * CONE RELATED FUNCTIONS
695 * 686 *
696 *****************************************************************************/ 687 *****************************************************************************/
697
698 688
699/* drops an object based on what is in the cone's "other_arch" */ 689/* drops an object based on what is in the cone's "other_arch" */
700void 690void
701cone_drop (object *op) 691cone_drop (object *op)
702{ 692{
… …
828 818
829 /* Need to know what the movetype of the object we are about 819 /* Need to know what the movetype of the object we are about
830 * to create is, so we can know if the space we are about to 820 * to create is, so we can know if the space we are about to
831 * insert it into is blocked. 821 * insert it into is blocked.
832 */ 822 */
833 movetype = spell->other_arch->clone.move_type; 823 movetype = spell->other_arch->move_type;
834 824
835 for (i = range_min; i <= range_max; i++) 825 for (i = range_min; i <= range_max; i++)
836 { 826 {
837 sint16 x, y, d; 827 sint16 x, y, d;
838 828
… …
917 else 907 else
918 tmp->duration += caster->level / 3; 908 tmp->duration += caster->level / 3;
919 } 909 }
920 910
921 if (!(tmp->move_type & MOVE_FLY_LOW)) 911 if (!(tmp->move_type & MOVE_FLY_LOW))
922 LOG (llevDebug, "cast_cone(): arch %s doesn't have flying 1\n", &spell->other_arch->name); 912 LOG (llevDebug, "cast_cone(): arch %s doesn't have flying 1\n", &spell->other_arch->archname);
923 913
924 if (!tmp->move_on && tmp->stats.dam) 914 if (!tmp->move_on && tmp->stats.dam)
925 LOG (llevDebug, "cast_cone(): arch %s doesn't have move_on set\n", &spell->other_arch->name); 915 LOG (llevDebug, "cast_cone(): arch %s doesn't have move_on set\n", &spell->other_arch->archname);
926 916
927 m->insert (tmp, sx, sy, op); 917 m->insert (tmp, sx, sy, op);
928 918
929 /* This is used for tracking spells so that one effect doesn't hit 919 /* This is used for tracking spells so that one effect doesn't hit
930 * a single space too many times. 920 * a single space too many times.
… …
942 * 932 *
943 * BOMB related code 933 * BOMB related code
944 * 934 *
945 ****************************************************************************/ 935 ****************************************************************************/
946 936
947
948/* This handles an exploding bomb. 937/* This handles an exploding bomb.
949 * op is the original bomb object. 938 * op is the original bomb object.
950 */ 939 */
951void 940void
952animate_bomb (object *op) 941animate_bomb (object *op)
953{ 942{
954 int i;
955 object *env, *tmp;
956
957 if (op->state != NUM_ANIMATIONS (op) - 1) 943 if (op->state != NUM_ANIMATIONS (op) - 1)
958 return; 944 return;
959 945
960 env = object_get_env_recursive (op); 946 object *env = op->outer_env ();
961 947
962 if (op->env) 948 if (op->env)
963 { 949 {
964 if (env->map == NULL) 950 if (env->map == NULL)
965 return; 951 return;
966
967 if (env->type == PLAYER)
968 esrv_del_item (env->contr, op->count);
969 952
970 if (!(op = op->insert_at (env, op))) 953 if (!(op = op->insert_at (env, op)))
971 return; 954 return;
972 } 955 }
973 956
… …
984 * but using the cast_bullet isn't really feasible, 967 * but using the cast_bullet isn't really feasible,
985 * so just set up the appropriate values. 968 * so just set up the appropriate values.
986 */ 969 */
987 if (archetype *at = archetype::find (SPLINT)) 970 if (archetype *at = archetype::find (SPLINT))
988 { 971 {
989 for (i = 1; i < 9; i++) 972 for (int i = 1; i < 9; i++)
990 { 973 {
991 if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i])) 974 if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))
992 continue; 975 continue;
993 976
994 tmp = arch_to_object (at); 977 object *tmp = arch_to_object (at);
995 tmp->direction = i; 978 tmp->direction = i;
996 tmp->range = op->range; 979 tmp->range = op->range;
997 tmp->stats.dam = op->stats.dam; 980 tmp->stats.dam = op->stats.dam;
998 tmp->duration = op->duration; 981 tmp->duration = op->duration;
999 tmp->attacktype = op->attacktype; 982 tmp->attacktype = op->attacktype;
… …
1013} 996}
1014 997
1015int 998int
1016create_bomb (object *op, object *caster, int dir, object *spell) 999create_bomb (object *op, object *caster, int dir, object *spell)
1017{ 1000{
1018
1019 object *tmp; 1001 object *tmp;
1020 int mflags; 1002 int mflags;
1021 sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir]; 1003 sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];
1022 maptile *m; 1004 maptile *m;
1023 1005
… …
1025 if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK)) 1007 if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
1026 { 1008 {
1027 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 1009 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
1028 return 0; 1010 return 0;
1029 } 1011 }
1012
1030 tmp = arch_to_object (spell->other_arch); 1013 tmp = arch_to_object (spell->other_arch);
1031 1014
1032 /* level dependencies for bomb */ 1015 /* level dependencies for bomb */
1033 tmp->range = spell->range + SP_level_range_adjust (caster, spell); 1016 tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1034 tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1017 tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
… …
1055 * dir is the direction to look in. 1038 * dir is the direction to look in.
1056 * range is how far out to look. 1039 * range is how far out to look.
1057 * type is the type of spell - either SPELL_MANA or SPELL_GRACE. 1040 * type is the type of spell - either SPELL_MANA or SPELL_GRACE.
1058 * this info is used for blocked magic/unholy spaces. 1041 * this info is used for blocked magic/unholy spaces.
1059 */ 1042 */
1060
1061object * 1043object *
1062get_pointed_target (object *op, int dir, int range, int type) 1044get_pointed_target (object *op, int dir, int range, int type)
1063{ 1045{
1064 object *target; 1046 object *target;
1065 sint16 x, y; 1047 sint16 x, y;
… …
1084 return NULL; 1066 return NULL;
1085 if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW) 1067 if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)
1086 return NULL; 1068 return NULL;
1087 1069
1088 if (mflags & P_IS_ALIVE) 1070 if (mflags & P_IS_ALIVE)
1089 {
1090 for (target = GET_MAP_OB (mp, x, y); target; target = target->above) 1071 for (target = GET_MAP_OB (mp, x, y); target; target = target->above)
1091 { 1072 if (QUERY_FLAG (target, FLAG_MONSTER))
1092 if (QUERY_FLAG (target->head ? target->head : target, FLAG_MONSTER))
1093 {
1094 return target; 1073 return target;
1095 }
1096 }
1097 }
1098 } 1074 }
1075
1099 return NULL; 1076 return NULL;
1100} 1077}
1101
1102 1078
1103/* cast_smite_arch() - the priest points to a creature and causes 1079/* cast_smite_arch() - the priest points to a creature and causes
1104 * a 'godly curse' to decend. 1080 * a 'godly curse' to decend.
1105 * usual params - 1081 * usual params -
1106 * op = player 1082 * op = player
1107 * caster = object casting the spell. 1083 * caster = object casting the spell.
1108 * dir = direction being cast 1084 * dir = direction being cast
1109 * spell = spell object 1085 * spell = spell object
1110 */ 1086 */
1111
1112int 1087int
1113cast_smite_spell (object *op, object *caster, int dir, object *spell) 1088cast_smite_spell (object *op, object *caster, int dir, object *spell)
1114{ 1089{
1115 object *effect, *target; 1090 object *effect, *target;
1116 object *god = find_god (determine_god (op)); 1091 object *god = find_god (determine_god (op));
… …
1194 effect->insert_at (target, op); 1169 effect->insert_at (target, op);
1195 1170
1196 return 1; 1171 return 1;
1197} 1172}
1198 1173
1199
1200/**************************************************************************** 1174/****************************************************************************
1201 * 1175 *
1202 * MAGIC MISSILE code. 1176 * MAGIC MISSILE code.
1203 * note that the fire_bullet is used to fire the missile. The 1177 * note that the fire_bullet is used to fire the missile. The
1204 * code here is just to move the missile. 1178 * code here is just to move the missile.
… …
1274 * we do this by creating a force and inserting it in the 1248 * we do this by creating a force and inserting it in the
1275 * object. if time is 0, the object glows permanently. To truely 1249 * object. if time is 0, the object glows permanently. To truely
1276 * make this work for non-living objects, we would have to 1250 * make this work for non-living objects, we would have to
1277 * give them the capability to have an inventory. b.t. 1251 * give them the capability to have an inventory. b.t.
1278 */ 1252 */
1279
1280int 1253int
1281make_object_glow (object *op, int radius, int time) 1254make_object_glow (object *op, int radius, int time)
1282{ 1255{
1283 object *tmp;
1284
1285 /* some things are unaffected... */ 1256 /* some things are unaffected... */
1286 if (op->path_denied & PATH_LIGHT) 1257 if (op->path_denied & PATH_LIGHT)
1287 return 0; 1258 return 0;
1288 1259
1289 tmp = get_archetype (FORCE_NAME); 1260 object *tmp = get_archetype (FORCE_NAME);
1290 tmp->speed = 0.01; 1261 tmp->speed = 0.01;
1291 tmp->stats.food = time; 1262 tmp->stats.food = time;
1292 SET_FLAG (tmp, FLAG_IS_USED_UP); 1263 SET_FLAG (tmp, FLAG_IS_USED_UP);
1293 tmp->glow_radius = radius; 1264 tmp->glow_radius = radius;
1294 if (tmp->glow_radius > MAX_LIGHT_RADII) 1265 if (tmp->glow_radius > MAX_LIGHT_RADII)
1295 tmp->glow_radius = MAX_LIGHT_RADII; 1266 tmp->glow_radius = MAX_LIGHT_RADII;
1296 1267
1297 tmp->x = op->x;
1298 tmp->y = op->y;
1299 if (tmp->speed < MIN_ACTIVE_SPEED)
1300 tmp->speed = MIN_ACTIVE_SPEED; /* safety */
1301 tmp = insert_ob_in_ob (tmp, op); 1268 tmp = insert_ob_in_ob (tmp, op);
1269
1302 if (tmp->glow_radius > op->glow_radius) 1270 if (tmp->glow_radius > op->glow_radius)
1303 op->glow_radius = tmp->glow_radius; 1271 op->glow_radius = tmp->glow_radius;
1304 1272
1305 if (!tmp->env || op != tmp->env)
1306 {
1307 LOG (llevError, "make_object_glow() failed to insert glowing force in %s\n", &op->name);
1308 return 0;
1309 }
1310 return 1; 1273 return 1;
1311} 1274}
1312
1313
1314
1315 1275
1316int 1276int
1317cast_destruction (object *op, object *caster, object *spell_ob) 1277cast_destruction (object *op, object *caster, object *spell_ob)
1318{ 1278{
1319 int i, j, range, mflags, friendly = 0, dam, dur; 1279 int i, j, range, mflags, friendly = 0, dam, dur;
… …
1340 else if (caster->skill) 1300 else if (caster->skill)
1341 op->skill = caster->skill; 1301 op->skill = caster->skill;
1342 else 1302 else
1343 op->skill = NULL; 1303 op->skill = NULL;
1344 1304
1345 change_skill (op, find_skill_by_name (op, op->skill), 1); 1305 op->change_skill (find_skill_by_name (op, op->skill));
1346 1306
1347 for (i = -range; i < range; i++) 1307 for (i = -range; i < range; i++)
1348 { 1308 {
1349 for (j = -range; j < range; j++) 1309 for (j = -range; j < range; j++)
1350 { 1310 {
… …
1408 { 1368 {
1409 new_draw_info (NDI_UNIQUE, 0, op, "There is no one in that direction to curse."); 1369 new_draw_info (NDI_UNIQUE, 0, op, "There is no one in that direction to curse.");
1410 return 0; 1370 return 0;
1411 } 1371 }
1412 1372
1373 tmp = tmp->head_ ();
1374
1413 /* If we've already got a force of this type, don't add a new one. */ 1375 /* If we've already got a force of this type, don't add a new one. */
1414 for (force = tmp->inv; force != NULL; force = force->below) 1376 for (force = tmp->inv; force; force = force->below)
1415 { 1377 {
1416 if (force->type == FORCE && force->subtype == FORCE_CHANGE_ABILITY) 1378 if (force->type == FORCE && force->subtype == FORCE_CHANGE_ABILITY)
1417 { 1379 {
1418 if (force->name == spell_ob->name) 1380 if (force->name == spell_ob->name)
1419 { 1381 {
… …
1425 return 0; 1387 return 0;
1426 } 1388 }
1427 } 1389 }
1428 } 1390 }
1429 1391
1430 if (force == NULL) 1392 if (!force)
1431 { 1393 {
1432 force = get_archetype (FORCE_NAME); 1394 force = get_archetype (FORCE_NAME);
1433 force->subtype = FORCE_CHANGE_ABILITY; 1395 force->subtype = FORCE_CHANGE_ABILITY;
1396
1434 if (spell_ob->race) 1397 if (spell_ob->race)
1435 force->name = spell_ob->race; 1398 force->name = spell_ob->race;
1436 else 1399 else
1437 force->name = spell_ob->name; 1400 force->name = spell_ob->name;
1438 1401
… …
1448 { 1411 {
1449 force->duration = duration; 1412 force->duration = duration;
1450 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 1413 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1451 } 1414 }
1452 else 1415 else
1453 {
1454 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect."); 1416 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1455 } 1417
1456 return 1; 1418 return 1;
1457 } 1419 }
1420
1458 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50; 1421 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1459 force->speed = 1.0; 1422 force->speed = 1.f;
1460 force->speed_left = -1.0; 1423 force->speed_left = -1.f;
1461 SET_FLAG (force, FLAG_APPLIED); 1424 SET_FLAG (force, FLAG_APPLIED);
1462 1425
1463 if (god) 1426 if (god)
1464 { 1427 {
1465 if (spell_ob->last_grace) 1428 if (spell_ob->last_grace)
… …
1585 at -= level / 5; 1548 at -= level / 5;
1586 if (did_make_save (head, head->level, at)) 1549 if (did_make_save (head, head->level, at))
1587 continue; 1550 continue;
1588 } 1551 }
1589 else /* spell->attacktype */ 1552 else /* spell->attacktype */
1590 /*
1591 Spell has no attacktype (charm & such), so we'll have a specific saving:
1592 * if spell level < monster level, no go
1593 * else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )
1594
1595 The chance will then be in the range [20-70] percent, not too bad.
1596
1597 This is required to fix the 'charm monster' abuse, where a player level 1 can
1598 charm a level 125 monster...
1599
1600 Ryo, august 14th
1601 */
1602 { 1553 {
1554 /*
1555 Spell has no attacktype (charm & such), so we'll have a specific saving:
1556 * if spell level < monster level, no go
1557 * else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )
1558
1559 The chance will then be in the range [20-70] percent, not too bad.
1560
1561 This is required to fix the 'charm monster' abuse, where a player level 1 can
1562 charm a level 125 monster...
1563
1564 Ryo, august 14th
1565 */
1603 if (head->level > level) 1566 if (head->level > level)
1604 continue; 1567 continue;
1568
1605 if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + MIN (50, 2 * (level - head->level)))) 1569 if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + MIN (50, 2 * (level - head->level))))
1606 /* Failed, no effect */ 1570 /* Failed, no effect */
1607 continue; 1571 continue;
1608 } 1572 }
1609 1573
… …
1611 1575
1612 /* aggravation */ 1576 /* aggravation */
1613 if (QUERY_FLAG (spell, FLAG_MONSTER)) 1577 if (QUERY_FLAG (spell, FLAG_MONSTER))
1614 { 1578 {
1615 CLEAR_FLAG (head, FLAG_SLEEP); 1579 CLEAR_FLAG (head, FLAG_SLEEP);
1616 if (QUERY_FLAG (head, FLAG_FRIENDLY))
1617 remove_friendly_object (head); 1580 remove_friendly_object (head);
1618
1619 done_one = 1; 1581 done_one = 1;
1620 head->enemy = op; 1582 head->enemy = op;
1621 } 1583 }
1622 1584
1623 /* calm monsters */ 1585 /* calm monsters */
… …
1723 * if this has an other_arch field, we insert that in 1685 * if this has an other_arch field, we insert that in
1724 * the surround spaces. 1686 * the surround spaces.
1725 */ 1687 */
1726 for (j = 0; j < 9; j++) 1688 for (j = 0; j < 9; j++)
1727 { 1689 {
1728 object *new_ob;
1729
1730 hx = nx + freearr_x[j]; 1690 hx = nx + freearr_x[j];
1731 hy = ny + freearr_y[j]; 1691 hy = ny + freearr_y[j];
1732 1692
1733 m = op->map; 1693 m = op->map;
1734 mflags = get_map_flags (m, &m, hx, hy, &hx, &hy); 1694 mflags = get_map_flags (m, &m, hx, hy, &hx, &hy);
… …
1810#if 0 1770#if 0
1811 // this is bogus: it causes wrong places to be checked below 1771 // this is bogus: it causes wrong places to be checked below
1812 // (a wall 2 cells away will block the effect...) and 1772 // (a wall 2 cells away will block the effect...) and
1813 // doesn't work for SP_BULLET anyhow, so again tests the wrong 1773 // doesn't work for SP_BULLET anyhow, so again tests the wrong
1814 // space. 1774 // space.
1815 // should be fixed later, but correctness before featurs... 1775 // should be fixed later, but correctness before features...
1816 // (schmorp) 1776 // (schmorp)
1817 1777
1818 /* new offset calculation to make swarm element distribution 1778 /* new offset calculation to make swarm element distribution
1819 * more uniform 1779 * more uniform
1820 */ 1780 */
… …
1996 1956
1997 m->insert (tmp, x, y, op); 1957 m->insert (tmp, x, y, op);
1998 return 1; 1958 return 1;
1999} 1959}
2000 1960
2001
2002
2003
2004/* cast_cause_disease: this spell looks along <dir> from the 1961/* cast_cause_disease: this spell looks along <dir> from the
2005 * player and infects someone. 1962 * player and infects someone.
2006 * op is the player/monster, caster is the object, dir is the direction 1963 * op is the player/monster, caster is the object, dir is the direction
2007 * to cast, disease_arch is the specific disease, and type is the spell number 1964 * to cast, disease_arch is the specific disease, and type is the spell number
2008 * perhaps this should actually be in disease.c? 1965 * perhaps this should actually be in disease.c?
2009 */ 1966 */
2010
2011int 1967int
2012cast_cause_disease (object *op, object *caster, object *spell, int dir) 1968cast_cause_disease (object *op, object *caster, object *spell, int dir)
2013{ 1969{
2014 sint16 x, y; 1970 sint16 x, y;
2015 int i, mflags, range, dam_mod, dur_mod; 1971 int i, mflags, range, dam_mod, dur_mod;
… …
2022 /* If casting from a scroll, no direction will be available, so refer to the 1978 /* If casting from a scroll, no direction will be available, so refer to the
2023 * direction the player is pointing. 1979 * direction the player is pointing.
2024 */ 1980 */
2025 if (!dir) 1981 if (!dir)
2026 dir = op->facing; 1982 dir = op->facing;
1983
2027 if (!dir) 1984 if (!dir)
2028 return 0; /* won't find anything if casting on ourself, so just return */ 1985 return 0; /* won't find anything if casting on ourself, so just return */
2029 1986
2030 /* Calculate these once here */ 1987 /* Calculate these once here */
2031 range = spell->range + SP_level_range_adjust (caster, spell); 1988 range = spell->range + SP_level_range_adjust (caster, spell);
… …
2065 /* do level adjustments */ 2022 /* do level adjustments */
2066 if (disease->stats.wc) 2023 if (disease->stats.wc)
2067 disease->stats.wc += dur_mod / 2; 2024 disease->stats.wc += dur_mod / 2;
2068 2025
2069 if (disease->magic > 0) 2026 if (disease->magic > 0)
2070 disease->magic += dur_mod / 4; 2027 disease->magic += dur_mod / 8;
2071 2028
2072 if (disease->stats.maxhp > 0) 2029 if (disease->stats.maxhp > 0)
2073 disease->stats.maxhp += dur_mod; 2030 disease->stats.maxhp += dur_mod;
2074 2031
2075 if (disease->stats.maxgrace > 0) 2032 if (disease->stats.maxgrace > 0)
… …
2110 if (disease->stats.sp) 2067 if (disease->stats.sp)
2111 disease->stats.sp -= dam_mod; 2068 disease->stats.sp -= dam_mod;
2112 2069
2113 if (infect_object (walk, disease, 1)) 2070 if (infect_object (walk, disease, 1))
2114 { 2071 {
2115 object *flash; /* visual effect for inflicting disease */
2116
2117 new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name); 2072 new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);
2118 2073
2119 disease->destroy (); /* don't need this one anymore */ 2074 disease->destroy (); /* don't need this one anymore */
2120 walk->map->insert (get_archetype (ARCH_DETECT_MAGIC), x, y, op); 2075 walk->map->insert (get_archetype ("detect_magic"), x, y, op);
2121 return 1; 2076 return 1;
2122 } 2077 }
2123 2078
2124 disease->destroy (); 2079 disease->destroy ();
2125 } 2080 }

Diff Legend

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