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.54 by root, Wed Apr 30 10:31:04 2008 UTC vs.
Revision 1.57 by root, Sat May 17 14:11:13 2008 UTC

… …
36/* this function checks to see if a spell pushes objects as well 36/* this function checks to see if a spell pushes objects as well
37 * as flies over and damages them (only used for cones for now) 37 * as flies over and damages them (only used for cones for now)
38 * but moved here so it could be applied to bolts too 38 * but moved here so it could be applied to bolts too
39 * op is the spell object. 39 * op is the spell object.
40 */ 40 */
41
42void 41void
43check_spell_knockback (object *op) 42check_spell_knockback (object *op)
44{ 43{
45 object *tmp, *tmp2; /* object on the map */ 44 object *tmp, *tmp2; /* object on the map */
46 int weight_move; 45 int weight_move;
… …
106 * 105 *
107 * BOLT CODE 106 * BOLT CODE
108 * 107 *
109 ***************************************************************************/ 108 ***************************************************************************/
110 109
111/* Causes op to fork. op is the original bolt, tmp 110/* Causes op to fork. op is the original bolt, tmp
112 * is the first piece of the fork. 111 * is the first piece of the fork.
113 */ 112 */
114
115void 113void
116forklightning (object *op, object *tmp) 114forklightning (object *op, object *tmp)
117{ 115{
118 int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */ 116 int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */
119 int t_dir; /* stores temporary dir calculation */ 117 int t_dir; /* stores temporary dir calculation */
… …
620 int mflags; 618 int mflags;
621 619
622 if (!spob->other_arch) 620 if (!spob->other_arch)
623 return 0; 621 return 0;
624 622
625 tmp = arch_to_object (spob->other_arch); 623 tmp = spob->other_arch->instance ();
626 if (tmp == NULL) 624 if (!tmp)
627 return 0; 625 return 0;
628 626
629 /* peterm: level dependency for bolts */ 627 /* peterm: level dependency for bolts */
630 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob); 628 tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
631 tmp->attacktype = spob->attacktype; 629 tmp->attacktype = spob->attacktype;
632 if (spob->slaying) 630 if (spob->slaying)
633 tmp->slaying = spob->slaying; 631 tmp->slaying = spob->slaying;
634 632
… …
644 SET_ANIMATION (tmp, dir); 642 SET_ANIMATION (tmp, dir);
645 643
646 tmp->set_owner (op); 644 tmp->set_owner (op);
647 set_spell_skill (op, caster, spob, tmp); 645 set_spell_skill (op, caster, spob, tmp);
648 646
649 tmp->x = op->x + freearr_x[dir]; 647 tmp->x = op->x + freearr_x[dir];
650 tmp->y = op->y + freearr_y[dir]; 648 tmp->y = op->y + freearr_y[dir];
651 tmp->map = op->map; 649 tmp->map = op->map;
652 650
653 maptile *newmap; 651 maptile *newmap;
654 mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y); 652 mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
655 if (mflags & P_OUT_OF_MAP) 653 if (mflags & P_OUT_OF_MAP)
… …
1729 1727
1730 op->direction = i; 1728 op->direction = i;
1731 } 1729 }
1732} 1730}
1733 1731
1734
1735/* move_swarm_spell: peterm 1732/* move_swarm_spell: peterm
1736 * This is an implementation of the swarm spell. It was written for 1733 * This is an implementation of the swarm spell. It was written for
1737 * meteor swarm, but it could be used for any swarm. A swarm spell 1734 * meteor swarm, but it could be used for any swarm. A swarm spell
1738 * is a special type of object that casts swarms of other types 1735 * is a special type of object that casts swarms of other types
1739 * of spells. Which spell it casts is flexible. It fires the spells 1736 * of spells. Which spell it casts is flexible. It fires the spells
1740 * from a set of squares surrounding the caster, in a given direction. 1737 * from a set of squares surrounding the caster, in a given direction.
1741 */ 1738 */
1742
1743void 1739void
1744move_swarm_spell (object *op) 1740move_swarm_spell (object *op)
1745{ 1741{
1746#if 0 1742#if 0
1747 static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 }; 1743 static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };
1748 static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 }; 1744 static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };
1749 sint16 target_x, target_y, origin_x, origin_y; 1745 sint16 target_x, target_y, origin_x, origin_y;
1750 int adjustdir; 1746 int adjustdir;
1751 maptile *m; 1747 maptile *m;
1752#endif 1748#endif
1753 int basedir;
1754 object *owner; 1749 object *owner = op->env;
1755 1750
1756 owner = op->owner; 1751 if (!op->duration || !owner->is_on_map ())
1757 if (op->duration == 0 || owner == NULL)
1758 { 1752 {
1759 op->destroy (); 1753 op->destroy ();
1760 return; 1754 return;
1761 } 1755 }
1762 1756
1763 op->duration--; 1757 op->duration--;
1764 1758
1765 basedir = op->direction; 1759 int basedir = op->direction;
1766 if (basedir == 0) 1760 if (!basedir)
1767 {
1768 /* spray in all directions! 8) */ 1761 /* spray in all directions! 8) */
1769 basedir = rndm (1, 8); 1762 basedir = (op->facing += op->state) % 8 + 1;
1770 }
1771 1763
1772#if 0 1764#if 0
1773 // this is bogus: it causes wrong places to be checked below 1765 // this is bogus: it causes wrong places to be checked below
1774 // (a wall 2 cells away will block the effect...) and 1766 // (a wall 2 cells away will block the effect...) and
1775 // doesn't work for SP_BULLET anyhow, so again tests the wrong 1767 // doesn't work for SP_BULLET anyhow, so again tests the wrong
… …
1835 { 1827 {
1836 /* Bullet spells have a bunch more customization that needs to be done */ 1828 /* Bullet spells have a bunch more customization that needs to be done */
1837 if (op->spell->subtype == SP_BULLET) 1829 if (op->spell->subtype == SP_BULLET)
1838 fire_bullet (owner, op, basedir, op->spell); 1830 fire_bullet (owner, op, basedir, op->spell);
1839 else if (op->spell->subtype == SP_MAGIC_MISSILE) 1831 else if (op->spell->subtype == SP_MAGIC_MISSILE)
1840 fire_arch_from_position (owner, op, op->x, op->y, basedir, op->spell); 1832 fire_arch_from_position (owner, op, owner->x, owner->y, basedir, op->spell);
1841 } 1833 }
1842} 1834}
1843
1844
1845
1846 1835
1847/* fire_swarm: 1836/* fire_swarm:
1848 * The following routine creates a swarm of objects. It actually 1837 * The following routine creates a swarm of objects. It actually
1849 * sets up a specific swarm object, which then fires off all 1838 * sets up a specific swarm object, which then fires off all
1850 * the parts of the swarm. 1839 * the parts of the swarm.
… …
1853 * caster: the caster (owner, wand, rod, scroll) 1842 * caster: the caster (owner, wand, rod, scroll)
1854 * dir: the direction everything will be fired in 1843 * dir: the direction everything will be fired in
1855 * spell - the spell that is this spell. 1844 * spell - the spell that is this spell.
1856 * n: the number to be fired. 1845 * n: the number to be fired.
1857 */ 1846 */
1858
1859int 1847int
1860fire_swarm (object *op, object *caster, object *spell, int dir) 1848fire_swarm (object *op, object *caster, object *spell, int dir)
1861{ 1849{
1862 object *tmp;
1863 int i;
1864
1865 if (!spell->other_arch) 1850 if (!spell->other_arch)
1866 return 0; 1851 return 0;
1867 1852
1868 tmp = get_archetype (SWARM_SPELL); 1853 object *tmp = archetype::get (SWARM_SPELL);
1869 tmp->set_owner (op); /* needed so that if swarm elements kill, caster gets xp. */
1870 set_spell_skill (op, caster, spell, tmp); 1854 set_spell_skill (op, caster, spell, tmp);
1871
1872 tmp->level = caster_level (caster, spell); /*needed later, to get level dep. right. */ 1855 tmp->level = caster_level (caster, spell); /* needed later, to get level dep. right. */
1873 tmp->spell = arch_to_object (spell->other_arch); 1856 tmp->spell = spell->other_arch->instance ();
1874
1875 tmp->attacktype = tmp->spell->attacktype; 1857 tmp->attacktype = tmp->spell->attacktype;
1876 1858
1877 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER) 1859 if (tmp->attacktype & AT_HOLYWORD || tmp->attacktype & AT_GODPOWER)
1878 if (!tailor_god_spell (tmp, op)) 1860 if (!tailor_god_spell (tmp, op))
1879 return 1; 1861 return 1;
1880 1862
1881 tmp->duration = SP_level_duration_adjust (caster, spell); 1863 tmp->duration = SP_level_duration_adjust (caster, spell);
1882 for (i = 0; i < spell->duration; i++) 1864 for (int i = 0; i < spell->duration; i++)
1883 tmp->duration += die_roll (1, 3, op, PREFER_HIGH); 1865 tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
1884 1866
1885 tmp->direction = dir; 1867 tmp->direction = dir;
1886 tmp->invisible = 1; 1868 tmp->invisible = 1;
1869 tmp->facing = rndm (1, 8); // initial firing direction
1870 tmp->state = rndm (4) * 2 + 1; // direction increment
1887 1871
1888 tmp->insert_at (op, op); 1872 op->insert (tmp);
1873
1889 return 1; 1874 return 1;
1890} 1875}
1891
1892 1876
1893/* See the spells documentation file for why this is its own 1877/* See the spells documentation file for why this is its own
1894 * function. 1878 * function.
1895 */ 1879 */
1896int 1880int

Diff Legend

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