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.43 by root, Thu Jul 5 08:10:30 2007 UTC vs.
Revision 1.53 by root, Tue Apr 22 07:01:47 2008 UTC

1/* 1/*
2 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team 4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002-2003,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002-2003,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * Crossfire TRT is free software: you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or 10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version. 11 * (at your option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
… …
16 * GNU General Public License for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * 20 *
21 * The authors can be reached via e-mail to <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <support@deliantra.net>
22 */ 22 */
23 23
24/* This file contains all the spell attack code. Grouping this code 24/* This file contains all the spell attack code. Grouping this code
25 * together should hopefully make it easier to find the relevent bits 25 * together should hopefully make it easier to find the relevent bits
26 * of code 26 * of code
… …
343 * BULLET/BALL CODE 343 * BULLET/BALL CODE
344 * 344 *
345 ***************************************************************************/ 345 ***************************************************************************/
346 346
347/* expands an explosion. op is a piece of the 347/* expands an explosion. op is a piece of the
348 * explosion - this expans it in the different directions. 348 * explosion - this expands it in the different directions.
349 * At least that is what I think this does. 349 * At least that is what I think this does.
350 */ 350 */
351void 351void
352explosion (object *op) 352explosion (object *op)
353{ 353{
… …
405 return; 405 return;
406 } 406 }
407 407
408 if (op->env) 408 if (op->env)
409 { 409 {
410 object *env = object_get_env_recursive (op); 410 object *env = op->outer_env ();
411
411 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))
412 { 413 {
413 LOG (llevError, "BUG: explode_bullet(): env out of map\n"); 414 LOG (llevError, "BUG: explode_bullet(): env out of map\n");
414 op->destroy (); 415 op->destroy ();
415 return; 416 return;
416 } 417 }
… …
483 484
484 /* Prevent recursion */ 485 /* Prevent recursion */
485 op->move_on = 0; 486 op->move_on = 0;
486 487
487 tmp->insert_at (op, op); 488 tmp->insert_at (op, op);
489 tmp->play_sound (tmp->sound);
490
488 /* remove the firebullet */ 491 /* remove the firebullet */
489 op->destroy (); 492 op->destroy ();
490} 493}
491 494
492/* 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
… …
935 * op is the original bomb object. 938 * op is the original bomb object.
936 */ 939 */
937void 940void
938animate_bomb (object *op) 941animate_bomb (object *op)
939{ 942{
940 int i;
941 object *env, *tmp;
942
943 if (op->state != NUM_ANIMATIONS (op) - 1) 943 if (op->state != NUM_ANIMATIONS (op) - 1)
944 return; 944 return;
945 945
946 env = object_get_env_recursive (op); 946 object *env = op->outer_env ();
947 947
948 if (op->env) 948 if (op->env)
949 { 949 {
950 if (env->map == NULL) 950 if (env->map == NULL)
951 return; 951 return;
952
953 if (env->type == PLAYER)
954 esrv_del_item (env->contr, op->count);
955 952
956 if (!(op = op->insert_at (env, op))) 953 if (!(op = op->insert_at (env, op)))
957 return; 954 return;
958 } 955 }
959 956
… …
970 * but using the cast_bullet isn't really feasible, 967 * but using the cast_bullet isn't really feasible,
971 * so just set up the appropriate values. 968 * so just set up the appropriate values.
972 */ 969 */
973 if (archetype *at = archetype::find (SPLINT)) 970 if (archetype *at = archetype::find (SPLINT))
974 { 971 {
975 for (i = 1; i < 9; i++) 972 for (int i = 1; i < 9; i++)
976 { 973 {
977 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]))
978 continue; 975 continue;
979 976
980 tmp = arch_to_object (at); 977 object *tmp = arch_to_object (at);
981 tmp->direction = i; 978 tmp->direction = i;
982 tmp->range = op->range; 979 tmp->range = op->range;
983 tmp->stats.dam = op->stats.dam; 980 tmp->stats.dam = op->stats.dam;
984 tmp->duration = op->duration; 981 tmp->duration = op->duration;
985 tmp->attacktype = op->attacktype; 982 tmp->attacktype = op->attacktype;
… …
999} 996}
1000 997
1001int 998int
1002create_bomb (object *op, object *caster, int dir, object *spell) 999create_bomb (object *op, object *caster, int dir, object *spell)
1003{ 1000{
1004
1005 object *tmp; 1001 object *tmp;
1006 int mflags; 1002 int mflags;
1007 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];
1008 maptile *m; 1004 maptile *m;
1009 1005
… …
1011 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))
1012 { 1008 {
1013 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.");
1014 return 0; 1010 return 0;
1015 } 1011 }
1012
1016 tmp = arch_to_object (spell->other_arch); 1013 tmp = arch_to_object (spell->other_arch);
1017 1014
1018 /* level dependencies for bomb */ 1015 /* level dependencies for bomb */
1019 tmp->range = spell->range + SP_level_range_adjust (caster, spell); 1016 tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1020 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);
… …
1085 * op = player 1082 * op = player
1086 * caster = object casting the spell. 1083 * caster = object casting the spell.
1087 * dir = direction being cast 1084 * dir = direction being cast
1088 * spell = spell object 1085 * spell = spell object
1089 */ 1086 */
1090
1091int 1087int
1092cast_smite_spell (object *op, object *caster, int dir, object *spell) 1088cast_smite_spell (object *op, object *caster, int dir, object *spell)
1093{ 1089{
1094 object *effect, *target; 1090 object *effect, *target;
1095 object *god = find_god (determine_god (op)); 1091 object *god = find_god (determine_god (op));
… …
1172 /* ok, tell it where to be, and insert! */ 1168 /* ok, tell it where to be, and insert! */
1173 effect->insert_at (target, op); 1169 effect->insert_at (target, op);
1174 1170
1175 return 1; 1171 return 1;
1176} 1172}
1177
1178 1173
1179/**************************************************************************** 1174/****************************************************************************
1180 * 1175 *
1181 * MAGIC MISSILE code. 1176 * MAGIC MISSILE code.
1182 * 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
… …
1373 { 1368 {
1374 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.");
1375 return 0; 1370 return 0;
1376 } 1371 }
1377 1372
1373 tmp = tmp->head_ ();
1374
1378 /* 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. */
1379 for (force = tmp->inv; force != NULL; force = force->below) 1376 for (force = tmp->inv; force; force = force->below)
1380 { 1377 {
1381 if (force->type == FORCE && force->subtype == FORCE_CHANGE_ABILITY) 1378 if (force->type == FORCE && force->subtype == FORCE_CHANGE_ABILITY)
1382 { 1379 {
1383 if (force->name == spell_ob->name) 1380 if (force->name == spell_ob->name)
1384 { 1381 {
… …
1390 return 0; 1387 return 0;
1391 } 1388 }
1392 } 1389 }
1393 } 1390 }
1394 1391
1395 if (force == NULL) 1392 if (!force)
1396 { 1393 {
1397 force = get_archetype (FORCE_NAME); 1394 force = get_archetype (FORCE_NAME);
1398 force->subtype = FORCE_CHANGE_ABILITY; 1395 force->subtype = FORCE_CHANGE_ABILITY;
1396
1399 if (spell_ob->race) 1397 if (spell_ob->race)
1400 force->name = spell_ob->race; 1398 force->name = spell_ob->race;
1401 else 1399 else
1402 force->name = spell_ob->name; 1400 force->name = spell_ob->name;
1403 1401
… …
1413 { 1411 {
1414 force->duration = duration; 1412 force->duration = duration;
1415 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.");
1416 } 1414 }
1417 else 1415 else
1418 {
1419 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.");
1420 } 1417
1421 return 1; 1418 return 1;
1422 } 1419 }
1420
1423 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;
1424 force->speed = 1.f; 1422 force->speed = 1.f;
1425 force->speed_left = -1.f; 1423 force->speed_left = -1.f;
1426 SET_FLAG (force, FLAG_APPLIED); 1424 SET_FLAG (force, FLAG_APPLIED);
1427 1425
… …
1958 1956
1959 m->insert (tmp, x, y, op); 1957 m->insert (tmp, x, y, op);
1960 return 1; 1958 return 1;
1961} 1959}
1962 1960
1963
1964
1965
1966/* cast_cause_disease: this spell looks along <dir> from the 1961/* cast_cause_disease: this spell looks along <dir> from the
1967 * player and infects someone. 1962 * player and infects someone.
1968 * 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
1969 * 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
1970 * perhaps this should actually be in disease.c? 1965 * perhaps this should actually be in disease.c?
1971 */ 1966 */
1972
1973int 1967int
1974cast_cause_disease (object *op, object *caster, object *spell, int dir) 1968cast_cause_disease (object *op, object *caster, object *spell, int dir)
1975{ 1969{
1976 sint16 x, y; 1970 sint16 x, y;
1977 int i, mflags, range, dam_mod, dur_mod; 1971 int i, mflags, range, dam_mod, dur_mod;
… …
1984 /* 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
1985 * direction the player is pointing. 1979 * direction the player is pointing.
1986 */ 1980 */
1987 if (!dir) 1981 if (!dir)
1988 dir = op->facing; 1982 dir = op->facing;
1983
1989 if (!dir) 1984 if (!dir)
1990 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 */
1991 1986
1992 /* Calculate these once here */ 1987 /* Calculate these once here */
1993 range = spell->range + SP_level_range_adjust (caster, spell); 1988 range = spell->range + SP_level_range_adjust (caster, spell);
… …
2027 /* do level adjustments */ 2022 /* do level adjustments */
2028 if (disease->stats.wc) 2023 if (disease->stats.wc)
2029 disease->stats.wc += dur_mod / 2; 2024 disease->stats.wc += dur_mod / 2;
2030 2025
2031 if (disease->magic > 0) 2026 if (disease->magic > 0)
2032 disease->magic += dur_mod / 4; 2027 disease->magic += dur_mod / 8;
2033 2028
2034 if (disease->stats.maxhp > 0) 2029 if (disease->stats.maxhp > 0)
2035 disease->stats.maxhp += dur_mod; 2030 disease->stats.maxhp += dur_mod;
2036 2031
2037 if (disease->stats.maxgrace > 0) 2032 if (disease->stats.maxgrace > 0)

Diff Legend

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