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.30 by pippijn, Thu Mar 1 12:28:16 2007 UTC vs.
Revision 1.52 by root, Tue Apr 22 02:46:18 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 */
… …
245 else 244 else
246 { /* Create a copy of this object and put it ahead */ 245 { /* Create a copy of this object and put it ahead */
247 object *tmp = op->clone (); 246 object *tmp = op->clone ();
248 247
249 m->insert (tmp, x, y, op); 248 m->insert (tmp, x, y, op);
250 tmp->speed_left = -0.1; 249 tmp->speed_left = -0.1f;
251 /* 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 */
252 tmp->duration++; 251 tmp->duration++;
253 252
254 /* New forking code. Possibly create forks of this object 253 /* New forking code. Possibly create forks of this object
255 * going off in other directions. 254 * going off in other directions.
… …
337 move_bolt (tmp); 336 move_bolt (tmp);
338 337
339 return 1; 338 return 1;
340} 339}
341 340
342
343
344/*************************************************************************** 341/***************************************************************************
345 * 342 *
346 * BULLET/BALL CODE 343 * BULLET/BALL CODE
347 * 344 *
348 ***************************************************************************/ 345 ***************************************************************************/
349 346
350/* expands an explosion. op is a piece of the 347/* expands an explosion. op is a piece of the
351 * explosion - this expans it in the different directions. 348 * explosion - this expands it in the different directions.
352 * At least that is what I think this does. 349 * At least that is what I think this does.
353 */ 350 */
354void 351void
355explosion (object *op) 352explosion (object *op)
356{ 353{
… …
380 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))
381 { 378 {
382 object *tmp = op->clone (); 379 object *tmp = op->clone ();
383 380
384 tmp->state = 0; 381 tmp->state = 0;
385 tmp->speed_left = -0.21; 382 tmp->speed_left = -0.21f;
386 tmp->range--; 383 tmp->range--;
387 tmp->value = 0; 384 tmp->value = 0;
388 385
389 m->insert (tmp, dx, dy, op); 386 m->insert (tmp, dx, dy, op);
390 } 387 }
391 } 388 }
392 } 389 }
393} 390}
394
395 391
396/* Causes an object to explode, eg, a firebullet, 392/* Causes an object to explode, eg, a firebullet,
397 * poison cloud ball, etc. op is the object to 393 * poison cloud ball, etc. op is the object to
398 * explode. 394 * explode.
399 */ 395 */
… …
409 return; 405 return;
410 } 406 }
411 407
412 if (op->env) 408 if (op->env)
413 { 409 {
414 object *env = object_get_env_recursive (op); 410 object *env = op->outer_env ();
411
415 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))
416 { 413 {
417 LOG (llevError, "BUG: explode_bullet(): env out of map\n"); 414 LOG (llevError, "BUG: explode_bullet(): env out of map\n");
418 op->destroy (); 415 op->destroy ();
419 return; 416 return;
420 } 417 }
… …
487 484
488 /* Prevent recursion */ 485 /* Prevent recursion */
489 op->move_on = 0; 486 op->move_on = 0;
490 487
491 tmp->insert_at (op, op); 488 tmp->insert_at (op, op);
489 tmp->play_sound (tmp->sound);
490
492 /* remove the firebullet */ 491 /* remove the firebullet */
493 op->destroy (); 492 op->destroy ();
494} 493}
495 494
496/* 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
… …
518 517
519 /* 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 */
520 if (!(mflags & P_IS_ALIVE)) 519 if (!(mflags & P_IS_ALIVE))
521 return; 520 return;
522 521
523 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)
524 { 523 {
525 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 524 if (QUERY_FLAG (tmp, FLAG_ALIVE))
526 { 525 {
527 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1); 526 dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
528 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0) 527 if (op->destroyed () || !tmp->destroyed () || (op->stats.dam -= dam) < 0)
… …
604 } 603 }
605 else 604 else
606 check_bullet (op); 605 check_bullet (op);
607} 606}
608 607
609
610
611
612/* fire_bullet 608/* fire_bullet
613 * object op (cast from caster) files a bolt in dir. 609 * object op (cast from caster) files a bolt in dir.
614 * spob is the spell object for the bolt. 610 * spob is the spell object for the bolt.
615 * we remove the magic flag - that can be derived from 611 * we remove the magic flag - that can be derived from
616 * spob->attacktype. 612 * spob->attacktype.
617 * This function sets up the appropriate owner and skill 613 * This function sets up the appropriate owner and skill
618 * pointers. 614 * pointers.
619 */ 615 */
620
621int 616int
622fire_bullet (object *op, object *caster, int dir, object *spob) 617fire_bullet (object *op, object *caster, int dir, object *spob)
623{ 618{
624 object *tmp = NULL; 619 object *tmp = NULL;
625 int mflags; 620 int mflags;
… …
683 check_bullet (tmp); 678 check_bullet (tmp);
684 679
685 return 1; 680 return 1;
686} 681}
687 682
688
689
690
691/***************************************************************************** 683/*****************************************************************************
692 * 684 *
693 * CONE RELATED FUNCTIONS 685 * CONE RELATED FUNCTIONS
694 * 686 *
695 *****************************************************************************/ 687 *****************************************************************************/
696
697 688
698/* 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" */
699void 690void
700cone_drop (object *op) 691cone_drop (object *op)
701{ 692{
… …
827 818
828 /* 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
829 * 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
830 * insert it into is blocked. 821 * insert it into is blocked.
831 */ 822 */
832 movetype = spell->other_arch->clone.move_type; 823 movetype = spell->other_arch->move_type;
833 824
834 for (i = range_min; i <= range_max; i++) 825 for (i = range_min; i <= range_max; i++)
835 { 826 {
836 sint16 x, y, d; 827 sint16 x, y, d;
837 828
… …
916 else 907 else
917 tmp->duration += caster->level / 3; 908 tmp->duration += caster->level / 3;
918 } 909 }
919 910
920 if (!(tmp->move_type & MOVE_FLY_LOW)) 911 if (!(tmp->move_type & MOVE_FLY_LOW))
921 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);
922 913
923 if (!tmp->move_on && tmp->stats.dam) 914 if (!tmp->move_on && tmp->stats.dam)
924 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);
925 916
926 m->insert (tmp, sx, sy, op); 917 m->insert (tmp, sx, sy, op);
927 918
928 /* 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
929 * a single space too many times. 920 * a single space too many times.
… …
941 * 932 *
942 * BOMB related code 933 * BOMB related code
943 * 934 *
944 ****************************************************************************/ 935 ****************************************************************************/
945 936
946
947/* This handles an exploding bomb. 937/* This handles an exploding bomb.
948 * op is the original bomb object. 938 * op is the original bomb object.
949 */ 939 */
950void 940void
951animate_bomb (object *op) 941animate_bomb (object *op)
952{ 942{
953 int i;
954 object *env, *tmp;
955
956 if (op->state != NUM_ANIMATIONS (op) - 1) 943 if (op->state != NUM_ANIMATIONS (op) - 1)
957 return; 944 return;
958 945
959 env = object_get_env_recursive (op); 946 object *env = op->outer_env ();
960 947
961 if (op->env) 948 if (op->env)
962 { 949 {
963 if (env->map == NULL) 950 if (env->map == NULL)
964 return; 951 return;
… …
983 * but using the cast_bullet isn't really feasible, 970 * but using the cast_bullet isn't really feasible,
984 * so just set up the appropriate values. 971 * so just set up the appropriate values.
985 */ 972 */
986 if (archetype *at = archetype::find (SPLINT)) 973 if (archetype *at = archetype::find (SPLINT))
987 { 974 {
988 for (i = 1; i < 9; i++) 975 for (int i = 1; i < 9; i++)
989 { 976 {
990 if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i])) 977 if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))
991 continue; 978 continue;
992 979
993 tmp = arch_to_object (at); 980 object *tmp = arch_to_object (at);
994 tmp->direction = i; 981 tmp->direction = i;
995 tmp->range = op->range; 982 tmp->range = op->range;
996 tmp->stats.dam = op->stats.dam; 983 tmp->stats.dam = op->stats.dam;
997 tmp->duration = op->duration; 984 tmp->duration = op->duration;
998 tmp->attacktype = op->attacktype; 985 tmp->attacktype = op->attacktype;
… …
1012} 999}
1013 1000
1014int 1001int
1015create_bomb (object *op, object *caster, int dir, object *spell) 1002create_bomb (object *op, object *caster, int dir, object *spell)
1016{ 1003{
1017
1018 object *tmp; 1004 object *tmp;
1019 int mflags; 1005 int mflags;
1020 sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir]; 1006 sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];
1021 maptile *m; 1007 maptile *m;
1022 1008
… …
1024 if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK)) 1010 if ((mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
1025 { 1011 {
1026 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 1012 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
1027 return 0; 1013 return 0;
1028 } 1014 }
1015
1029 tmp = arch_to_object (spell->other_arch); 1016 tmp = arch_to_object (spell->other_arch);
1030 1017
1031 /* level dependencies for bomb */ 1018 /* level dependencies for bomb */
1032 tmp->range = spell->range + SP_level_range_adjust (caster, spell); 1019 tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1033 tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1020 tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
… …
1054 * dir is the direction to look in. 1041 * dir is the direction to look in.
1055 * range is how far out to look. 1042 * range is how far out to look.
1056 * type is the type of spell - either SPELL_MANA or SPELL_GRACE. 1043 * type is the type of spell - either SPELL_MANA or SPELL_GRACE.
1057 * this info is used for blocked magic/unholy spaces. 1044 * this info is used for blocked magic/unholy spaces.
1058 */ 1045 */
1059
1060object * 1046object *
1061get_pointed_target (object *op, int dir, int range, int type) 1047get_pointed_target (object *op, int dir, int range, int type)
1062{ 1048{
1063 object *target; 1049 object *target;
1064 sint16 x, y; 1050 sint16 x, y;
… …
1083 return NULL; 1069 return NULL;
1084 if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW) 1070 if (GET_MAP_MOVE_BLOCK (mp, x, y) & MOVE_FLY_LOW)
1085 return NULL; 1071 return NULL;
1086 1072
1087 if (mflags & P_IS_ALIVE) 1073 if (mflags & P_IS_ALIVE)
1088 {
1089 for (target = GET_MAP_OB (mp, x, y); target; target = target->above) 1074 for (target = GET_MAP_OB (mp, x, y); target; target = target->above)
1090 { 1075 if (QUERY_FLAG (target, FLAG_MONSTER))
1091 if (QUERY_FLAG (target->head ? target->head : target, FLAG_MONSTER))
1092 {
1093 return target; 1076 return target;
1094 }
1095 }
1096 }
1097 } 1077 }
1078
1098 return NULL; 1079 return NULL;
1099} 1080}
1100
1101 1081
1102/* cast_smite_arch() - the priest points to a creature and causes 1082/* cast_smite_arch() - the priest points to a creature and causes
1103 * a 'godly curse' to decend. 1083 * a 'godly curse' to decend.
1104 * usual params - 1084 * usual params -
1105 * op = player 1085 * op = player
1106 * caster = object casting the spell. 1086 * caster = object casting the spell.
1107 * dir = direction being cast 1087 * dir = direction being cast
1108 * spell = spell object 1088 * spell = spell object
1109 */ 1089 */
1110
1111int 1090int
1112cast_smite_spell (object *op, object *caster, int dir, object *spell) 1091cast_smite_spell (object *op, object *caster, int dir, object *spell)
1113{ 1092{
1114 object *effect, *target; 1093 object *effect, *target;
1115 object *god = find_god (determine_god (op)); 1094 object *god = find_god (determine_god (op));
… …
1193 effect->insert_at (target, op); 1172 effect->insert_at (target, op);
1194 1173
1195 return 1; 1174 return 1;
1196} 1175}
1197 1176
1198
1199/**************************************************************************** 1177/****************************************************************************
1200 * 1178 *
1201 * MAGIC MISSILE code. 1179 * MAGIC MISSILE code.
1202 * note that the fire_bullet is used to fire the missile. The 1180 * note that the fire_bullet is used to fire the missile. The
1203 * code here is just to move the missile. 1181 * code here is just to move the missile.
… …
1273 * we do this by creating a force and inserting it in the 1251 * we do this by creating a force and inserting it in the
1274 * object. if time is 0, the object glows permanently. To truely 1252 * object. if time is 0, the object glows permanently. To truely
1275 * make this work for non-living objects, we would have to 1253 * make this work for non-living objects, we would have to
1276 * give them the capability to have an inventory. b.t. 1254 * give them the capability to have an inventory. b.t.
1277 */ 1255 */
1278
1279int 1256int
1280make_object_glow (object *op, int radius, int time) 1257make_object_glow (object *op, int radius, int time)
1281{ 1258{
1282 object *tmp;
1283
1284 /* some things are unaffected... */ 1259 /* some things are unaffected... */
1285 if (op->path_denied & PATH_LIGHT) 1260 if (op->path_denied & PATH_LIGHT)
1286 return 0; 1261 return 0;
1287 1262
1288 tmp = get_archetype (FORCE_NAME); 1263 object *tmp = get_archetype (FORCE_NAME);
1289 tmp->speed = 0.01; 1264 tmp->speed = 0.01;
1290 tmp->stats.food = time; 1265 tmp->stats.food = time;
1291 SET_FLAG (tmp, FLAG_IS_USED_UP); 1266 SET_FLAG (tmp, FLAG_IS_USED_UP);
1292 tmp->glow_radius = radius; 1267 tmp->glow_radius = radius;
1293 if (tmp->glow_radius > MAX_LIGHT_RADII) 1268 if (tmp->glow_radius > MAX_LIGHT_RADII)
1294 tmp->glow_radius = MAX_LIGHT_RADII; 1269 tmp->glow_radius = MAX_LIGHT_RADII;
1295 1270
1296 tmp->x = op->x;
1297 tmp->y = op->y;
1298 if (tmp->speed < MIN_ACTIVE_SPEED)
1299 tmp->speed = MIN_ACTIVE_SPEED; /* safety */
1300 tmp = insert_ob_in_ob (tmp, op); 1271 tmp = insert_ob_in_ob (tmp, op);
1272
1301 if (tmp->glow_radius > op->glow_radius) 1273 if (tmp->glow_radius > op->glow_radius)
1302 op->glow_radius = tmp->glow_radius; 1274 op->glow_radius = tmp->glow_radius;
1303 1275
1304 if (!tmp->env || op != tmp->env)
1305 {
1306 LOG (llevError, "make_object_glow() failed to insert glowing force in %s\n", &op->name);
1307 return 0;
1308 }
1309 return 1; 1276 return 1;
1310} 1277}
1311
1312
1313
1314 1278
1315int 1279int
1316cast_destruction (object *op, object *caster, object *spell_ob) 1280cast_destruction (object *op, object *caster, object *spell_ob)
1317{ 1281{
1318 int i, j, range, mflags, friendly = 0, dam, dur; 1282 int i, j, range, mflags, friendly = 0, dam, dur;
… …
1339 else if (caster->skill) 1303 else if (caster->skill)
1340 op->skill = caster->skill; 1304 op->skill = caster->skill;
1341 else 1305 else
1342 op->skill = NULL; 1306 op->skill = NULL;
1343 1307
1344 change_skill (op, find_skill_by_name (op, op->skill), 1); 1308 op->change_skill (find_skill_by_name (op, op->skill));
1345 1309
1346 for (i = -range; i < range; i++) 1310 for (i = -range; i < range; i++)
1347 { 1311 {
1348 for (j = -range; j < range; j++) 1312 for (j = -range; j < range; j++)
1349 { 1313 {
… …
1407 { 1371 {
1408 new_draw_info (NDI_UNIQUE, 0, op, "There is no one in that direction to curse."); 1372 new_draw_info (NDI_UNIQUE, 0, op, "There is no one in that direction to curse.");
1409 return 0; 1373 return 0;
1410 } 1374 }
1411 1375
1376 tmp = tmp->head_ ();
1377
1412 /* If we've already got a force of this type, don't add a new one. */ 1378 /* If we've already got a force of this type, don't add a new one. */
1413 for (force = tmp->inv; force != NULL; force = force->below) 1379 for (force = tmp->inv; force; force = force->below)
1414 { 1380 {
1415 if (force->type == FORCE && force->subtype == FORCE_CHANGE_ABILITY) 1381 if (force->type == FORCE && force->subtype == FORCE_CHANGE_ABILITY)
1416 { 1382 {
1417 if (force->name == spell_ob->name) 1383 if (force->name == spell_ob->name)
1418 { 1384 {
… …
1424 return 0; 1390 return 0;
1425 } 1391 }
1426 } 1392 }
1427 } 1393 }
1428 1394
1429 if (force == NULL) 1395 if (!force)
1430 { 1396 {
1431 force = get_archetype (FORCE_NAME); 1397 force = get_archetype (FORCE_NAME);
1432 force->subtype = FORCE_CHANGE_ABILITY; 1398 force->subtype = FORCE_CHANGE_ABILITY;
1399
1433 if (spell_ob->race) 1400 if (spell_ob->race)
1434 force->name = spell_ob->race; 1401 force->name = spell_ob->race;
1435 else 1402 else
1436 force->name = spell_ob->name; 1403 force->name = spell_ob->name;
1437 1404
… …
1447 { 1414 {
1448 force->duration = duration; 1415 force->duration = duration;
1449 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 1416 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1450 } 1417 }
1451 else 1418 else
1452 {
1453 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect."); 1419 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1454 } 1420
1455 return 1; 1421 return 1;
1456 } 1422 }
1423
1457 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50; 1424 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1458 force->speed = 1.0; 1425 force->speed = 1.f;
1459 force->speed_left = -1.0; 1426 force->speed_left = -1.f;
1460 SET_FLAG (force, FLAG_APPLIED); 1427 SET_FLAG (force, FLAG_APPLIED);
1461 1428
1462 if (god) 1429 if (god)
1463 { 1430 {
1464 if (spell_ob->last_grace) 1431 if (spell_ob->last_grace)
… …
1584 at -= level / 5; 1551 at -= level / 5;
1585 if (did_make_save (head, head->level, at)) 1552 if (did_make_save (head, head->level, at))
1586 continue; 1553 continue;
1587 } 1554 }
1588 else /* spell->attacktype */ 1555 else /* spell->attacktype */
1589 /*
1590 Spell has no attacktype (charm & such), so we'll have a specific saving:
1591 * if spell level < monster level, no go
1592 * else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )
1593
1594 The chance will then be in the range [20-70] percent, not too bad.
1595
1596 This is required to fix the 'charm monster' abuse, where a player level 1 can
1597 charm a level 125 monster...
1598
1599 Ryo, august 14th
1600 */
1601 { 1556 {
1557 /*
1558 Spell has no attacktype (charm & such), so we'll have a specific saving:
1559 * if spell level < monster level, no go
1560 * else, chance of effect = 20 + min( 50, 2 * ( spell level - monster level ) )
1561
1562 The chance will then be in the range [20-70] percent, not too bad.
1563
1564 This is required to fix the 'charm monster' abuse, where a player level 1 can
1565 charm a level 125 monster...
1566
1567 Ryo, august 14th
1568 */
1602 if (head->level > level) 1569 if (head->level > level)
1603 continue; 1570 continue;
1571
1604 if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + MIN (50, 2 * (level - head->level)))) 1572 if (random_roll (0, 100, caster, PREFER_LOW) >= (20 + MIN (50, 2 * (level - head->level))))
1605 /* Failed, no effect */ 1573 /* Failed, no effect */
1606 continue; 1574 continue;
1607 } 1575 }
1608 1576
… …
1610 1578
1611 /* aggravation */ 1579 /* aggravation */
1612 if (QUERY_FLAG (spell, FLAG_MONSTER)) 1580 if (QUERY_FLAG (spell, FLAG_MONSTER))
1613 { 1581 {
1614 CLEAR_FLAG (head, FLAG_SLEEP); 1582 CLEAR_FLAG (head, FLAG_SLEEP);
1615 if (QUERY_FLAG (head, FLAG_FRIENDLY))
1616 remove_friendly_object (head); 1583 remove_friendly_object (head);
1617
1618 done_one = 1; 1584 done_one = 1;
1619 head->enemy = op; 1585 head->enemy = op;
1620 } 1586 }
1621 1587
1622 /* calm monsters */ 1588 /* calm monsters */
… …
1807#if 0 1773#if 0
1808 // this is bogus: it causes wrong places to be checked below 1774 // this is bogus: it causes wrong places to be checked below
1809 // (a wall 2 cells away will block the effect...) and 1775 // (a wall 2 cells away will block the effect...) and
1810 // doesn't work for SP_BULLET anyhow, so again tests the wrong 1776 // doesn't work for SP_BULLET anyhow, so again tests the wrong
1811 // space. 1777 // space.
1812 // should be fixed later, but correctness before featurs... 1778 // should be fixed later, but correctness before features...
1813 // (schmorp) 1779 // (schmorp)
1814 1780
1815 /* new offset calculation to make swarm element distribution 1781 /* new offset calculation to make swarm element distribution
1816 * more uniform 1782 * more uniform
1817 */ 1783 */
… …
1993 1959
1994 m->insert (tmp, x, y, op); 1960 m->insert (tmp, x, y, op);
1995 return 1; 1961 return 1;
1996} 1962}
1997 1963
1998
1999
2000
2001/* cast_cause_disease: this spell looks along <dir> from the 1964/* cast_cause_disease: this spell looks along <dir> from the
2002 * player and infects someone. 1965 * player and infects someone.
2003 * op is the player/monster, caster is the object, dir is the direction 1966 * op is the player/monster, caster is the object, dir is the direction
2004 * to cast, disease_arch is the specific disease, and type is the spell number 1967 * to cast, disease_arch is the specific disease, and type is the spell number
2005 * perhaps this should actually be in disease.c? 1968 * perhaps this should actually be in disease.c?
2006 */ 1969 */
2007
2008int 1970int
2009cast_cause_disease (object *op, object *caster, object *spell, int dir) 1971cast_cause_disease (object *op, object *caster, object *spell, int dir)
2010{ 1972{
2011 sint16 x, y; 1973 sint16 x, y;
2012 int i, mflags, range, dam_mod, dur_mod; 1974 int i, mflags, range, dam_mod, dur_mod;
… …
2019 /* If casting from a scroll, no direction will be available, so refer to the 1981 /* If casting from a scroll, no direction will be available, so refer to the
2020 * direction the player is pointing. 1982 * direction the player is pointing.
2021 */ 1983 */
2022 if (!dir) 1984 if (!dir)
2023 dir = op->facing; 1985 dir = op->facing;
1986
2024 if (!dir) 1987 if (!dir)
2025 return 0; /* won't find anything if casting on ourself, so just return */ 1988 return 0; /* won't find anything if casting on ourself, so just return */
2026 1989
2027 /* Calculate these once here */ 1990 /* Calculate these once here */
2028 range = spell->range + SP_level_range_adjust (caster, spell); 1991 range = spell->range + SP_level_range_adjust (caster, spell);
… …
2062 /* do level adjustments */ 2025 /* do level adjustments */
2063 if (disease->stats.wc) 2026 if (disease->stats.wc)
2064 disease->stats.wc += dur_mod / 2; 2027 disease->stats.wc += dur_mod / 2;
2065 2028
2066 if (disease->magic > 0) 2029 if (disease->magic > 0)
2067 disease->magic += dur_mod / 4; 2030 disease->magic += dur_mod / 8;
2068 2031
2069 if (disease->stats.maxhp > 0) 2032 if (disease->stats.maxhp > 0)
2070 disease->stats.maxhp += dur_mod; 2033 disease->stats.maxhp += dur_mod;
2071 2034
2072 if (disease->stats.maxgrace > 0) 2035 if (disease->stats.maxgrace > 0)
… …
2110 if (infect_object (walk, disease, 1)) 2073 if (infect_object (walk, disease, 1))
2111 { 2074 {
2112 new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name); 2075 new_draw_info_format (NDI_UNIQUE, 0, op, "You inflict %s on %s!", &disease->name, &walk->name);
2113 2076
2114 disease->destroy (); /* don't need this one anymore */ 2077 disease->destroy (); /* don't need this one anymore */
2115 walk->map->insert (get_archetype (ARCH_DETECT_MAGIC), x, y, op); 2078 walk->map->insert (get_archetype ("detect_magic"), x, y, op);
2116 return 1; 2079 return 1;
2117 } 2080 }
2118 2081
2119 disease->destroy (); 2082 disease->destroy ();
2120 } 2083 }

Diff Legend

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