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

Comparing deliantra/server/server/spell_util.C (file contents):
Revision 1.98 by root, Sun Oct 4 19:49:12 2009 UTC vs.
Revision 1.109 by root, Sun Nov 29 17:41:08 2009 UTC

… …
3 * 3 *
4 * Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * Deliantra is free software: you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify it under
9 * it under the terms of the GNU General Public License as published by 9 * the terms of the Affero GNU General Public License as published by the
10 * the Free Software Foundation, either version 3 of the License, or 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * (at your option) any later version. 11 * 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 Affero GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>.
20 * 21 *
21 * The authors can be reached via e-mail to <support@deliantra.net> 22 * The authors can be reached via e-mail to <support@deliantra.net>
22 */ 23 */
23 24
24#include <global.h> 25#include <global.h>
… …
82 */ 83 */
83void 84void
84spell_effect (object *spob, int x, int y, maptile *map, object *originator) 85spell_effect (object *spob, int x, int y, maptile *map, object *originator)
85{ 86{
86 if (spob->other_arch) 87 if (spob->other_arch)
87 map->insert (arch_to_object (spob->other_arch), x, y, originator); 88 map->insert (spob->other_arch->instance (), x, y, originator);
88} 89}
89 90
90static int 91static int
91attuned_bonus (object *caster, object *spell, int level) 92attuned_bonus (object *caster, object *spell, int level)
92{ 93{
… …
148 int sp, grace, level = casting_level (caster, spell); 149 int sp, grace, level = casting_level (caster, spell);
149 150
150 if (settings.spellpoint_level_depend == TRUE) 151 if (settings.spellpoint_level_depend == TRUE)
151 { 152 {
152 if (spell->stats.sp && spell->stats.maxsp) 153 if (spell->stats.sp && spell->stats.maxsp)
153 {
154 sp = (int) (spell->stats.sp * (1.0 + MAX (0, (float) (level - spell->level) / (float) spell->stats.maxsp))); 154 sp = spell->stats.sp * (1.f + max (0.f, float (level - spell->level) / spell->stats.maxsp));
155 }
156 else 155 else
157 sp = spell->stats.sp; 156 sp = spell->stats.sp;
158 157
159 sp *= (int) PATH_SP_MULT (caster, spell); 158 sp *= (int) PATH_SP_MULT (caster, spell);
160 if (!sp && spell->stats.sp) 159 if (!sp && spell->stats.sp)
161 sp = 1; 160 sp = 1;
162 161
163 if (spell->stats.grace && spell->stats.maxgrace) 162 if (spell->stats.grace && spell->stats.maxgrace)
164 {
165 grace = (int) (spell->stats.grace * (1.0 + MAX (0, (float) (level - spell->level) / (float) spell->stats.maxgrace))); 163 grace = spell->stats.grace * (1.0 + max (0, float (level - spell->level) / spell->stats.maxgrace));
166 }
167 else 164 else
168 grace = spell->stats.grace; 165 grace = spell->stats.grace;
169 166
170 grace *= (int) PATH_SP_MULT (caster, spell); 167 grace *= PATH_SP_MULT (caster, spell);
171 if (spell->stats.grace && !grace) 168 if (spell->stats.grace && !grace)
172 grace = 1; 169 grace = 1;
173 } 170 }
174 else 171 else
175 { 172 {
… …
181 if (spell->stats.grace && !grace) 178 if (spell->stats.grace && !grace)
182 grace = 1; 179 grace = 1;
183 } 180 }
184 181
185 if (flags == SPELL_HIGHEST) 182 if (flags == SPELL_HIGHEST)
186 return MAX (sp, grace); 183 return max (sp, grace);
187 else if (flags == SPELL_GRACE) 184 else if (flags == SPELL_GRACE)
188 return grace; 185 return grace;
189 else if (flags == SPELL_MANA) 186 else if (flags == SPELL_MANA)
190 return sp; 187 return sp;
191 else 188 else
… …
535 ****************************************************************************/ 532 ****************************************************************************/
536void 533void
537regenerate_rod (object *rod) 534regenerate_rod (object *rod)
538{ 535{
539 if (rod->stats.hp < rod->stats.maxhp) 536 if (rod->stats.hp < rod->stats.maxhp)
540 rod->stats.hp = min (rod->stats.maxhp, rod->stats.hp + 1 + rod->stats.maxhp / 10); 537 rod->stats.hp = min (rod->stats.maxhp, rod->stats.hp + 1 + rod->stats.maxhp / 20);
541} 538}
542 539
543void 540void
544drain_rod_charge (object *rod) 541drain_rod_charge (object *rod)
545{ 542{
… …
637 634
638/* put_a_monster: puts a monster named monstername near by 635/* put_a_monster: puts a monster named monstername near by
639 * op. This creates the treasures for the monsters, and 636 * op. This creates the treasures for the monsters, and
640 * also deals with multipart monsters properly. 637 * also deals with multipart monsters properly.
641 */ 638 */
642void 639static void
643put_a_monster (object *op, const char *monstername) 640put_a_monster (object *op, const char *monstername)
644{ 641{
645 object *tmp, *head = NULL, *prev = NULL; 642 object *tmp, *head = NULL, *prev = NULL;
646 archetype *at; 643 archetype *at;
647 int dir; 644 int dir;
… …
662 * insert multipart monsters properly 659 * insert multipart monsters properly
663 */ 660 */
664 //TODO: use expand_tail + ... 661 //TODO: use expand_tail + ...
665 while (at != NULL) 662 while (at != NULL)
666 { 663 {
667 tmp = arch_to_object (at); 664 tmp = at->instance ();
668 tmp->x = op->x + freearr_x[dir] + at->x; 665 tmp->x = op->x + freearr_x[dir] + at->x;
669 tmp->y = op->y + freearr_y[dir] + at->y; 666 tmp->y = op->y + freearr_y[dir] + at->y;
670 tmp->map = op->map; 667 tmp->map = op->map;
671 if (head) 668 if (head)
672 { 669 {
… …
783 * at casting a prayer. 780 * at casting a prayer.
784 * op is the player. 781 * op is the player.
785 * failure is basically how much grace they had. 782 * failure is basically how much grace they had.
786 * power is how much grace the spell would normally take to cast. 783 * power is how much grace the spell would normally take to cast.
787 */ 784 */
788void 785static void
789prayer_failure (object *op, int failure, int power) 786prayer_failure (object *op, int failure, int power)
790{ 787{
791 const char *godname; 788 const char *godname;
792 object *tmp; 789 object *tmp;
793 790
… …
886 tmp->insert_at (op); 883 tmp->insert_at (op);
887 } 884 }
888 } 885 }
889} 886}
890 887
891int 888static int
892cast_party_spell (object *op, object *caster, int dir, object *spell_ob, char *spellparam) 889cast_party_spell (object *op, object *caster, int dir, object *spell_ob, char *spellparam)
893{ 890{
894 if (!spell_ob->other_arch) 891 if (!spell_ob->other_arch)
895 { 892 {
896 LOG (llevError, "cast_party_spell: empty other arch\n"); 893 LOG (llevError, "cast_party_spell: empty other arch\n");
897 return 0; 894 return 0;
898 } 895 }
899 896
900 object *spell = arch_to_object (spell_ob->other_arch); 897 object *spell = spell_ob->other_arch->instance ();
901 898
902 /* Always cast spell on caster */ 899 /* Always cast spell on caster */
903 int success = cast_spell (op, caster, dir, spell, spellparam); 900 int success = cast_spell (op, caster, dir, spell, spellparam);
904 901
905 if (!op->contr || !op->contr->party) 902 if (!op->contr || !op->contr->party)
… …
1053 } 1050 }
1054 } 1051 }
1055 1052
1056 /* player/monster is trying to cast the spell. might fumble it */ 1053 /* player/monster is trying to cast the spell. might fumble it */
1057 if (spell_ob->stats.grace && random_roll (0, 99, op, PREFER_HIGH) < 1054 if (spell_ob->stats.grace && random_roll (0, 99, op, PREFER_HIGH) <
1058 (spell_ob->level / (float) MAX (1, op->level) * cleric_chance[op->stats.Wis])) 1055 (spell_ob->level / (float) max (1, op->level) * cleric_chance[op->stats.Wis]))
1059 { 1056 {
1060 op->contr->play_sound (sound_find ("fumble_spell")); 1057 op->contr->play_sound (sound_find ("fumble_spell"));
1061 op->failmsg ("You fumble the prayer."); 1058 op->failmsg ("You fumble the prayer.");
1062 1059
1063 op->stats.grace -= random_roll (1, SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE), op, PREFER_LOW); 1060 op->stats.grace -= random_roll (1, SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE), op, PREFER_LOW);
… …
1129 * the player any time. 1126 * the player any time.
1130 * Ignore casting time for firewalls 1127 * Ignore casting time for firewalls
1131 */ 1128 */
1132 if (caster == op && caster->type != FIREWALL) 1129 if (caster == op && caster->type != FIREWALL)
1133 { 1130 {
1134 op->speed_left -= spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed); 1131 op->speed_left -= spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * op->speed;
1135 /* Other portions of the code may also decrement the speed of the player, so 1132 /* Other portions of the code may also decrement the speed of the player, so
1136 * put a lower limit so that the player isn't stuck here too long 1133 * put a lower limit so that the player isn't stuck here too long
1137 */ 1134 */
1138 if ((spell_ob->casting_time > 0) && op->speed_left < -spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed)) 1135 if ((spell_ob->casting_time > 0) && op->speed_left < -spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * op->speed)
1139 op->speed_left = -spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * FABS (op->speed); 1136 op->speed_left = -spell_ob->casting_time * PATH_TIME_MULT (op, spell_ob) * op->speed;
1140 } 1137 }
1141 else if (caster->type == WAND || caster->type == HORN || caster->type == ROD || caster->type == POTION || caster->type == SCROLL) 1138 else if (caster->type == WAND || caster->type == HORN || caster->type == ROD || caster->type == POTION || caster->type == SCROLL)
1142 op->speed_left -= 2 * FABS (op->speed); 1139 op->speed_left -= 2 * op->speed;
1143 1140
1144 if (op->type == PLAYER && op == caster) 1141 if (op->type == PLAYER && op == caster)
1145 { 1142 {
1146 op->stats.grace -= SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE); 1143 op->stats.grace -= SP_level_spellpoint_cost (caster, spell_ob, SPELL_GRACE);
1147 op->stats.sp -= SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA); 1144 op->stats.sp -= SP_level_spellpoint_cost (caster, spell_ob, SPELL_MANA);
… …
1445 move_aura (op); 1442 move_aura (op);
1446 break; 1443 break;
1447 } 1444 }
1448} 1445}
1449 1446
1450/* this checks to see if something special should happen if
1451 * something runs into the object.
1452 */
1453void
1454check_spell_effect (object *op)
1455{
1456 switch (op->subtype)
1457 {
1458 case SP_BOLT:
1459 move_bolt (op);
1460 return;
1461
1462 case SP_BULLET:
1463 check_bullet (op);
1464 return;
1465 }
1466}
1467
1468/* This is called by move_apply. Basically, if someone 1447/* This is called by move_apply. Basically, if someone
1469 * moves onto a spell effect and the walk_on or fly_on flags 1448 * moves onto a spell effect and the walk_on or fly_on flags
1470 * are set, this is called. This should only be called for 1449 * are set, this is called. This should only be called for
1471 * objects of the appropriate type. 1450 * objects of the appropriate type.
1472 */ 1451 */
… …
1474apply_spell_effect (object *spell, object *victim) 1453apply_spell_effect (object *spell, object *victim)
1475{ 1454{
1476 switch (spell->subtype) 1455 switch (spell->subtype)
1477 { 1456 {
1478 case SP_CONE: 1457 case SP_CONE:
1479 if (QUERY_FLAG (victim, FLAG_ALIVE) && spell->speed && spell->attacktype) 1458 if (QUERY_FLAG (victim, FLAG_ALIVE) && spell->has_active_speed () && spell->attacktype)
1480 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 0); 1459 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 0);
1481 break; 1460 break;
1482 1461
1483 case SP_MAGIC_MISSILE: 1462 case SP_MAGIC_MISSILE:
1484 if (QUERY_FLAG (victim, FLAG_ALIVE)) 1463 if (QUERY_FLAG (victim, FLAG_ALIVE))
… …
1489 break; 1468 break;
1490 1469
1491 case SP_MOVING_BALL: 1470 case SP_MOVING_BALL:
1492 if (QUERY_FLAG (victim, FLAG_ALIVE)) 1471 if (QUERY_FLAG (victim, FLAG_ALIVE))
1493 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1); 1472 hit_player (victim, spell->stats.dam, spell, spell->attacktype, 1);
1494 else if (victim->materialname) 1473 else if (victim->material != MATERIAL_NULL)
1495 save_throw_object (victim, spell->attacktype, spell); 1474 save_throw_object (victim, spell->attacktype, spell);
1496 1475
1497 break; 1476 break;
1498 } 1477 }
1499} 1478}

Diff Legend

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