[ViewVC] Diff of: cvs/deliantra/server/server/spell

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.44 by root, Sun Jul 22 14:17:58 2007 UTC vs.
Revision 1.61 by root, Sun May 18 19:53:07 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
…		…
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
42	void	41	void
43	check_spell_knockback (object *op)	42	check_spell_knockback (object *op)
44	{	43	{
45	object tmp, tmp2; /* object on the map */
46	int weight_move;	44	int weight_move;
47	int frictionmod = 2; /poor man's physics - multipy targets weight by this amount /	45	int frictionmod = 2; /poor man's physics - multipy targets weight by this amount /
48		46
49	if (!op->weight)	47	if (!op->weight)
50	{ /shouldn't happen but if cone object has no weight drop out /	48	{ /shouldn't happen but if cone object has no weight drop out /
…		…
55	{	53	{
56	weight_move = op->weight + (op->weight * op->level) / 3;	54	weight_move = op->weight + (op->weight * op->level) / 3;
57	/LOG (llevDebug, "DEBUG: arch weighs %d and masses %d (%s,level %d)\n", op->weight,weight_move,op->name,op->level); /	55	/LOG (llevDebug, "DEBUG: arch weighs %d and masses %d (%s,level %d)\n", op->weight,weight_move,op->name,op->level); /
58	}	56	}
59		57
60	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)	58	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
61	{	59	{
62	int num_sections = 1;	60	int num_sections = 1;
63		61
64	/* don't move DM */	62	/* don't move DM */
65	if (QUERY_FLAG (tmp, FLAG_WIZ))	63	if (QUERY_FLAG (tmp, FLAG_WIZ))
…		…
72	/* don't move floors or immobile objects */	70	/* don't move floors or immobile objects */
73	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) \|\| (!QUERY_FLAG (tmp, FLAG_ALIVE) && QUERY_FLAG (tmp, FLAG_NO_PICK)))	71	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) \|\| (!QUERY_FLAG (tmp, FLAG_ALIVE) && QUERY_FLAG (tmp, FLAG_NO_PICK)))
74	continue;	72	continue;
75		73
76	/* count the object's sections */	74	/* count the object's sections */
77	for (tmp2 = tmp; tmp2 != NULL; tmp2 = tmp2->more)	75	for (object *tmp2 = tmp; tmp2; tmp2 = tmp2->more)
78	num_sections++;	76	num_sections++;
79		77
80	/* I'm not sure if it makes sense to divide by num_sections - bigger	78	/* I'm not sure if it makes sense to divide by num_sections - bigger
81	* objects should be harder to move, and we are moving the entire	79	* objects should be harder to move, and we are moving the entire
82	* object, not just the head, so the total weight should be relevant.	80	* object, not just the head, so the total weight should be relevant.
…		…
106	*	104	*
107	* BOLT CODE	105	* BOLT CODE
108	*	106	*
109	***************************************************************************/	107	***************************************************************************/
110		108
111	/* Causes op to fork. op is the original bolt, tmp	109	/* Causes op to fork. op is the original bolt, tmp
112	* is the first piece of the fork.	110	* is the first piece of the fork.
113	*/	111	*/
114
115	void	112	void
116	forklightning (object op, object tmp)	113	forklightning (object op, object tmp)
117	{	114	{
118	int new_dir = 1; /* direction or -1 for left, +1 for right 0 if no new bolt */	115	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 */	116	int t_dir; /* stores temporary dir calculation */
…		…
151	new_bolt->duration++;	148	new_bolt->duration++;
152	new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */	149	new_bolt->stats.dam /= 2; /* reduce daughter bolt damage */
153	new_bolt->stats.dam++;	150	new_bolt->stats.dam++;
154	tmp->stats.dam /= 2; /* reduce father bolt damage */	151	tmp->stats.dam /= 2; /* reduce father bolt damage */
155	tmp->stats.dam++;	152	tmp->stats.dam++;
		153
156	if ((new_bolt = m->insert (new_bolt, sx, sy, op)))	154	if ((new_bolt = m->insert (new_bolt, sx, sy, op)))
157	update_turn_face (new_bolt);	155	update_turn_face (new_bolt);
158	}	156	}
159		157
160	/* move_bolt: moves bolt 'op'. Basically, it just advances a space,	158	/* move_bolt: moves bolt 'op'. Basically, it just advances a space,
161	* and checks for various things that may stop it.	159	* and checks for various things that may stop it.
162	*/	160	*/
163
164	void	161	void
165	move_bolt (object *op)	162	move_bolt (object *op)
166	{	163	{
167	int mflags;	164	int mflags;
168	sint16 x, y;	165	sint16 x, y;
…		…
251	tmp->duration++;	248	tmp->duration++;
252		249
253	/* New forking code. Possibly create forks of this object	250	/* New forking code. Possibly create forks of this object
254	* going off in other directions.	251	* going off in other directions.
255	*/	252	*/
256	if (rndm (0, 99) < tmp->stats.Dex)	253	if (tmp->stats.Dex && rndm (0, 99) < tmp->stats.Dex)
257	{ /* stats.Dex % of forking */	254	forklightning (op, tmp); /* stats.Dex % of forking */
258	forklightning (op, tmp);
259	}
260		255
261	/* In this way, the object left behind sticks on the space, but	256	/* In this way, the object left behind sticks on the space, but
262	* doesn't create any bolts that continue to move onward.	257	* doesn't create any bolts that continue to move onward.
263	*/	258	*/
264	op->range = 0;	259	op->range = 0;
…		…
288	return 0;	283	return 0;
289		284
290	/* peterm: level dependency for bolts */	285	/* peterm: level dependency for bolts */
291	tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);	286	tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
292	tmp->attacktype = spob->attacktype;	287	tmp->attacktype = spob->attacktype;
		288
293	if (spob->slaying)	289	if (spob->slaying)
294	tmp->slaying = spob->slaying;	290	tmp->slaying = spob->slaying;
		291
295	tmp->range = spob->range + SP_level_range_adjust (caster, spob);	292	tmp->range = spob->range + SP_level_range_adjust (caster, spob);
296	tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);	293	tmp->duration = spob->duration + SP_level_duration_adjust (caster, spob);
297	tmp->stats.Dex = spob->stats.Dex;	294	tmp->stats.Dex = spob->stats.Dex;
298	tmp->stats.Con = spob->stats.Con;	295	tmp->stats.Con = spob->stats.Con;
299		296
…		…
343	* BULLET/BALL CODE	340	* BULLET/BALL CODE
344	*	341	*
345	***************************************************************************/	342	***************************************************************************/
346		343
347	/* expands an explosion. op is a piece of the	344	/* expands an explosion. op is a piece of the
348	* explosion - this expans it in the different directions.	345	* explosion - this expands it in the different directions.
349	* At least that is what I think this does.	346	* At least that is what I think this does.
350	*/	347	*/
351	void	348	void
352	explosion (object *op)	349	explosion (object *op)
353	{	350	{
…		…
405	return;	402	return;
406	}	403	}
407		404
408	if (op->env)	405	if (op->env)
409	{	406	{
410	object *env = object_get_env_recursive (op);	407	object *env = op->outer_env ();
		408
411	if (env->map == NULL \|\| out_of_map (env->map, env->x, env->y))	409	if (!env->map \|\| out_of_map (env->map, env->x, env->y))
412	{	410	{
413	LOG (llevError, "BUG: explode_bullet(): env out of map\n");	411	LOG (llevError, "BUG: explode_bullet(): env out of map\n");
414	op->destroy ();	412	op->destroy ();
415	return;	413	return;
416	}	414	}
…		…
434	}	432	}
435		433
436	if (op->attacktype)	434	if (op->attacktype)
437	{	435	{
438	hit_map (op, 0, op->attacktype, 1);	436	hit_map (op, 0, op->attacktype, 1);
		437
439	if (op->destroyed ())	438	if (op->destroyed ())
440	return;	439	return;
441	}	440	}
442		441
443	/* other_arch contains what this explodes into */	442	/* other_arch contains what this explodes into */
…		…
483		482
484	/* Prevent recursion */	483	/* Prevent recursion */
485	op->move_on = 0;	484	op->move_on = 0;
486		485
487	tmp->insert_at (op, op);	486	tmp->insert_at (op, op);
		487	tmp->play_sound (tmp->sound);
		488
488	/* remove the firebullet */	489	/* remove the firebullet */
489	op->destroy ();	490	op->destroy ();
490	}	491	}
491		492
492	/* checks to see what op should do, given the space it is on	493	/* checks to see what op should do, given the space it is on
…		…
519	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)	520	for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
520	{	521	{
521	if (QUERY_FLAG (tmp, FLAG_ALIVE))	522	if (QUERY_FLAG (tmp, FLAG_ALIVE))
522	{	523	{
523	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);	524	dam = hit_player (tmp, op->stats.dam, op, op->attacktype, 1);
		525
524	if (op->destroyed () \|\| !tmp->destroyed () \|\| (op->stats.dam -= dam) < 0)	526	if (op->destroyed () \|\| !tmp->destroyed () \|\| (op->stats.dam -= dam) < 0)
525	{	527	{
526	if (!QUERY_FLAG (op, FLAG_REMOVED))	528	if (!QUERY_FLAG (op, FLAG_REMOVED))
527	{	529	{
528	op->destroy ();	530	op->destroy ();
…		…
617	int mflags;	619	int mflags;
618		620
619	if (!spob->other_arch)	621	if (!spob->other_arch)
620	return 0;	622	return 0;
621		623
622	tmp = arch_to_object (spob->other_arch);	624	tmp = spob->other_arch->instance ();
623	if (tmp == NULL)	625	if (!tmp)
624	return 0;	626	return 0;
625		627
626	/* peterm: level dependency for bolts */	628	/* peterm: level dependency for bolts */
627	tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);	629	tmp->stats.dam = spob->stats.dam + SP_level_dam_adjust (caster, spob);
628	tmp->attacktype = spob->attacktype;	630	tmp->attacktype = spob->attacktype;
629	if (spob->slaying)	631	if (spob->slaying)
630	tmp->slaying = spob->slaying;	632	tmp->slaying = spob->slaying;
631		633
…		…
641	SET_ANIMATION (tmp, dir);	643	SET_ANIMATION (tmp, dir);
642		644
643	tmp->set_owner (op);	645	tmp->set_owner (op);
644	set_spell_skill (op, caster, spob, tmp);	646	set_spell_skill (op, caster, spob, tmp);
645		647
646	tmp->x = op->x + freearr_x[dir];	648	tmp->x = op->x + freearr_x[dir];
647	tmp->y = op->y + freearr_y[dir];	649	tmp->y = op->y + freearr_y[dir];
648	tmp->map = op->map;	650	tmp->map = op->map;
649		651
650	maptile *newmap;	652	maptile *newmap;
651	mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);	653	mflags = get_map_flags (tmp->map, &newmap, tmp->x, tmp->y, &tmp->x, &tmp->y);
652	if (mflags & P_OUT_OF_MAP)	654	if (mflags & P_OUT_OF_MAP)
…		…
702	/* move_cone: causes cone object 'op' to move a space/hit creatures */	704	/* move_cone: causes cone object 'op' to move a space/hit creatures */
703		705
704	void	706	void
705	move_cone (object *op)	707	move_cone (object *op)
706	{	708	{
707	int i;
708
709	/* if no map then hit_map will crash so just ignore object */	709	/* if no map then hit_map will crash so just ignore object */
710	if (!op->map)	710	if (!op->map)
711	{	711	{
712	LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");	712	LOG (llevError, "Tried to move_cone object %s without a map.\n", op->name ? &op->name : "unknown");
713	op->set_speed (0);	713	op->set_speed (0);
…		…
758	{	758	{
759	op->range = 0; /* just so it doesn't wrap */	759	op->range = 0; /* just so it doesn't wrap */
760	return;	760	return;
761	}	761	}
762		762
763	for (i = -1; i < 2; i++)	763	for (int i = -1; i <= 1; i++)
764	{	764	{
765	sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];	765	sint16 x = op->x + freearr_x[absdir (op->stats.sp + i)], y = op->y + freearr_y[absdir (op->stats.sp + i)];
766		766
767	if (ok_to_put_more (op->map, x, y, op, op->attacktype))	767	if (ok_to_put_more (op->map, x, y, op, op->attacktype))
768	{	768	{
…		…
935	* op is the original bomb object.	935	* op is the original bomb object.
936	*/	936	*/
937	void	937	void
938	animate_bomb (object *op)	938	animate_bomb (object *op)
939	{	939	{
940	int i;
941	object env, tmp;
942
943	if (op->state != NUM_ANIMATIONS (op) - 1)	940	if (op->state != NUM_ANIMATIONS (op) - 1)
944	return;	941	return;
945		942
946	env = object_get_env_recursive (op);	943	object *env = op->outer_env ();
947		944
948	if (op->env)	945	if (op->env)
949	{	946	{
950	if (env->map == NULL)	947	if (env->map == NULL)
951	return;	948	return;
952
953	if (env->type == PLAYER)
954	esrv_del_item (env->contr, op->count);
955		949
956	if (!(op = op->insert_at (env, op)))	950	if (!(op = op->insert_at (env, op)))
957	return;	951	return;
958	}	952	}
959		953
…		…
970	* but using the cast_bullet isn't really feasible,	964	* but using the cast_bullet isn't really feasible,
971	* so just set up the appropriate values.	965	* so just set up the appropriate values.
972	*/	966	*/
973	if (archetype *at = archetype::find (SPLINT))	967	if (archetype *at = archetype::find (SPLINT))
974	{	968	{
975	for (i = 1; i < 9; i++)	969	for (int i = 1; i < 9; i++)
976	{	970	{
977	if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))	971	if (out_of_map (op->map, op->x + freearr_x[i], op->y + freearr_x[i]))
978	continue;	972	continue;
979		973
980	tmp = arch_to_object (at);	974	object *tmp = arch_to_object (at);
981	tmp->direction = i;	975	tmp->direction = i;
982	tmp->range = op->range;	976	tmp->range = op->range;
983	tmp->stats.dam = op->stats.dam;	977	tmp->stats.dam = op->stats.dam;
984	tmp->duration = op->duration;	978	tmp->duration = op->duration;
985	tmp->attacktype = op->attacktype;	979	tmp->attacktype = op->attacktype;
…		…
999	}	993	}
1000		994
1001	int	995	int
1002	create_bomb (object op, object caster, int dir, object *spell)	996	create_bomb (object op, object caster, int dir, object *spell)
1003	{	997	{
1004
1005	object *tmp;	998	object *tmp;
1006	int mflags;	999	int mflags;
1007	sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];	1000	sint16 dx = op->x + freearr_x[dir], dy = op->y + freearr_y[dir];
1008	maptile *m;	1001	maptile *m;
1009		1002
…		…
1011	if ((mflags & P_OUT_OF_MAP) \|\| (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))	1004	if ((mflags & P_OUT_OF_MAP) \|\| (GET_MAP_MOVE_BLOCK (m, dx, dy) & MOVE_WALK))
1012	{	1005	{
1013	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	1006	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
1014	return 0;	1007	return 0;
1015	}	1008	}
		1009
1016	tmp = arch_to_object (spell->other_arch);	1010	tmp = arch_to_object (spell->other_arch);
1017		1011
1018	/* level dependencies for bomb */	1012	/* level dependencies for bomb */
1019	tmp->range = spell->range + SP_level_range_adjust (caster, spell);	1013	tmp->range = spell->range + SP_level_range_adjust (caster, spell);
1020	tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1014	tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
…		…
1172	effect->insert_at (target, op);	1166	effect->insert_at (target, op);
1173		1167
1174	return 1;	1168	return 1;
1175	}	1169	}
1176		1170
1177
1178	/****************************************************************************	1171	/****************************************************************************
1179	*	1172	*
1180	* MAGIC MISSILE code.	1173	* MAGIC MISSILE code.
1181	* note that the fire_bullet is used to fire the missile. The	1174	* note that the fire_bullet is used to fire the missile. The
1182	* code here is just to move the missile.	1175	* code here is just to move the missile.
…		…
1184		1177
1185	/* op is a missile that needs to be moved */	1178	/* op is a missile that needs to be moved */
1186	void	1179	void
1187	move_missile (object *op)	1180	move_missile (object *op)
1188	{	1181	{
1189	int i, mflags;
1190	object *owner;
1191	sint16 new_x, new_y;
1192	maptile *m;
1193
1194	if (op->range-- <= 0)	1182	if (op->range-- <= 0)
1195	{	1183	{
1196	op->destroy ();	1184	op->destroy ();
1197	return;	1185	return;
1198	}	1186	}
1199		1187
1200	owner = op->owner;	1188	mapxy pos (op);
1201	#if 0	1189	pos.move (op->direction);
1202	/* It'd make things nastier if this wasn't here - spells cast by	1190
1203	* monster that are then killed would continue to survive	1191	if (!pos.normalise ())
1204	*/
1205	if (owner == NULL)
1206	{	1192	{
1207	op->destroy ();	1193	op->destroy ();
1208	return;	1194	return;
1209	}	1195	}
1210	#endif
1211		1196
1212	new_x = op->x + DIRX (op);	1197	mapspace &ms = pos.ms ();
1213	new_y = op->y + DIRY (op);
1214		1198
1215	mflags = get_map_flags (op->map, &m, new_x, new_y, &new_x, &new_y);	1199	if (ms.flags () & P_IS_ALIVE \|\| ms.blocks (op))
1216
1217	if (!(mflags & P_OUT_OF_MAP) && ((mflags & P_IS_ALIVE) \|\| OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y))))
1218	{	1200	{
1219	hit_map (op, op->direction, AT_MAGIC, 1);	1201	hit_map (op, op->direction, AT_MAGIC, 1);
1220	/* Basically, missile only hits one thing then goes away.	1202	/* Basically, missile only hits one thing then goes away.
1221	* we need to remove it if someone hasn't already done so.	1203	* we need to remove it if someone hasn't already done so.
1222	*/	1204	*/
1223	if (!op->destroyed ())
1224	op->destroy ();
1225
1226	return;
1227	}
1228
1229	op->remove ();
1230
1231	if (!op->direction \|\| (mflags & P_OUT_OF_MAP))
1232	{
1233	op->destroy ();	1205	op->destroy ();
1234	return;	1206	return;
1235	}	1207	}
1236		1208
		1209	if (!op->direction)
		1210	{
		1211	op->destroy ();
		1212	return;
		1213	}
		1214
1237	i = spell_find_dir (m, new_x, new_y, op->owner);	1215	int i = spell_find_dir (pos.m, pos.x, pos.y, op->owner);
1238	if (i > 0 && i != op->direction)	1216	if (i > 0 && i != op->direction)
1239	{	1217	{
1240	op->direction = i;	1218	op->direction = i;
1241	SET_ANIMATION (op, op->direction);	1219	SET_ANIMATION (op, op->direction);
1242	}	1220	}
1243		1221
1244	m->insert (op, new_x, new_y, op);	1222	pos.insert (op, op);
1245	}	1223	}
1246		1224
1247	/****************************************************************************	1225	/****************************************************************************
1248	* Destruction	1226	* Destruction
1249	****************************************************************************/	1227	****************************************************************************/
…		…
1306	else	1284	else
1307	op->skill = NULL;	1285	op->skill = NULL;
1308		1286
1309	op->change_skill (find_skill_by_name (op, op->skill));	1287	op->change_skill (find_skill_by_name (op, op->skill));
1310		1288
1311	for (i = -range; i < range; i++)	1289	for (i = -range; i <= range; i++)
1312	{	1290	{
1313	for (j = -range; j < range; j++)	1291	for (j = -range; j <= range; j++)
1314	{	1292	{
1315	m = op->map;	1293	m = op->map;
1316	sx = op->x + i;	1294	sx = op->x + i;
1317	sy = op->y + j;	1295	sy = op->y + j;
1318		1296
…		…
1335	(!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) \|\| tmp->type == PLAYER)))	1313	(!friendly && (QUERY_FLAG (tmp, FLAG_FRIENDLY) \|\| tmp->type == PLAYER)))
1336	{	1314	{
1337	if (spell_ob->subtype == SP_DESTRUCTION)	1315	if (spell_ob->subtype == SP_DESTRUCTION)
1338	{	1316	{
1339	hit_player (tmp, dam, op, spell_ob->attacktype, 0);	1317	hit_player (tmp, dam, op, spell_ob->attacktype, 0);
		1318
1340	if (spell_ob->other_arch)	1319	if (spell_ob->other_arch)
1341	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);	1320	m->insert (arch_to_object (spell_ob->other_arch), sx, sy, op);
1342	}	1321	}
1343	else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)	1322	else if (spell_ob->subtype == SP_FAERY_FIRE && tmp->resist[ATNR_MAGIC] != 100)
1344	{	1323	{
…		…
1372	{	1351	{
1373	new_draw_info (NDI_UNIQUE, 0, op, "There is no one in that direction to curse.");	1352	new_draw_info (NDI_UNIQUE, 0, op, "There is no one in that direction to curse.");
1374	return 0;	1353	return 0;
1375	}	1354	}
1376		1355
		1356	tmp = tmp->head_ ();
		1357
1377	/* If we've already got a force of this type, don't add a new one. */	1358	/* If we've already got a force of this type, don't add a new one. */
1378	for (force = tmp->inv; force != NULL; force = force->below)	1359	for (force = tmp->inv; force; force = force->below)
1379	{	1360	{
1380	if (force->type == FORCE && force->subtype == FORCE_CHANGE_ABILITY)	1361	if (force->type == FORCE && force->subtype == FORCE_CHANGE_ABILITY)
1381	{	1362	{
1382	if (force->name == spell_ob->name)	1363	if (force->name == spell_ob->name)
1383	{	1364	{
…		…
1389	return 0;	1370	return 0;
1390	}	1371	}
1391	}	1372	}
1392	}	1373	}
1393		1374
1394	if (force == NULL)	1375	if (!force)
1395	{	1376	{
1396	force = get_archetype (FORCE_NAME);	1377	force = get_archetype (FORCE_NAME);
1397	force->subtype = FORCE_CHANGE_ABILITY;	1378	force->subtype = FORCE_CHANGE_ABILITY;
		1379
1398	if (spell_ob->race)	1380	if (spell_ob->race)
1399	force->name = spell_ob->race;	1381	force->name = spell_ob->race;
1400	else	1382	else
1401	force->name = spell_ob->name;	1383	force->name = spell_ob->name;
1402		1384
…		…
1412	{	1394	{
1413	force->duration = duration;	1395	force->duration = duration;
1414	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");	1396	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1415	}	1397	}
1416	else	1398	else
1417	{
1418	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");	1399	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1419	}	1400
1420	return 1;	1401	return 1;
1421	}	1402	}
		1403
1422	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1404	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1423	force->speed = 1.f;	1405	force->speed = 1.f;
1424	force->speed_left = -1.f;	1406	force->speed_left = -1.f;
1425	SET_FLAG (force, FLAG_APPLIED);	1407	SET_FLAG (force, FLAG_APPLIED);
1426		1408
…		…
1599	}	1581	}
1600		1582
1601	/* charm */	1583	/* charm */
1602	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))	1584	if (QUERY_FLAG (spell, FLAG_NO_ATTACK) && !QUERY_FLAG (head, FLAG_FRIENDLY))
1603	{	1585	{
		1586	INVOKE_OBJECT (KILL, head, ARG_OBJECT (caster));
		1587
1604	/* Prevent uncontolled outbreaks of self replicating monsters.	1588	/* Prevent uncontrolled outbreaks of self replicating monsters.
1605	Typical use case is charm, go somwhere, use aggravation to make hostile.	1589	Typical use case is charm, go somwhere, use aggravation to make hostile.
1606	This could lead to fun stuff like mice outbreak in bigworld and server crawl. */	1590	This could lead to fun stuff like mice outbreak in bigworld and server crawl. */
1607	CLEAR_FLAG (head, FLAG_GENERATOR);	1591	CLEAR_FLAG (head, FLAG_GENERATOR);
1608	head->set_owner (op);	1592	head->set_owner (op);
1609	set_spell_skill (op, caster, spell, head);	1593	set_spell_skill (op, caster, spell, head);
…		…
1627	* about. was called move_ball_lightning, but since more than the ball	1611	* about. was called move_ball_lightning, but since more than the ball
1628	* lightning spell used it, that seemed misnamed.	1612	* lightning spell used it, that seemed misnamed.
1629	* op is the spell effect.	1613	* op is the spell effect.
1630	* note that duration is handled by process_object() in time.c	1614	* note that duration is handled by process_object() in time.c
1631	*/	1615	*/
1632
1633	void	1616	void
1634	move_ball_spell (object *op)	1617	move_ball_spell (object *op)
1635	{	1618	{
1636	int i, j, dam_save, dir, mflags;	1619	int i, j, dam_save, dir, mflags;
1637	sint16 nx, ny, hx, hy;	1620	sint16 nx, ny, hx, hy;
…		…
1703		1686
1704	if ((mflags & P_IS_ALIVE) && (!owner \|\| owner->x != hx \|\| owner->y != hy \|\| !on_same_map (owner, op)))	1687	if ((mflags & P_IS_ALIVE) && (!owner \|\| owner->x != hx \|\| owner->y != hy \|\| !on_same_map (owner, op)))
1705	{	1688	{
1706	if (j)	1689	if (j)
1707	op->stats.dam = dam_save / 2;	1690	op->stats.dam = dam_save / 2;
		1691
1708	hit_map (op, j, op->attacktype, 1);	1692	hit_map (op, j, op->attacktype, 1);
1709
1710	}	1693	}
1711		1694
1712	/* insert the other arch */	1695	/* insert the other arch */
1713	if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))	1696	if (op->other_arch && !(OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, hx, hy))))
1714	m->insert (arch_to_object (op->other_arch), hx, hy, op);	1697	m->insert (arch_to_object (op->other_arch), hx, hy, op);
…		…
1728		1711
1729	op->direction = i;	1712	op->direction = i;
1730	}	1713	}
1731	}	1714	}
1732		1715
1733
1734	/* move_swarm_spell: peterm	1716	/* move_swarm_spell: peterm
1735	* This is an implementation of the swarm spell. It was written for	1717	* This is an implementation of the swarm spell. It was written for
1736	* meteor swarm, but it could be used for any swarm. A swarm spell	1718	* meteor swarm, but it could be used for any swarm. A swarm spell
1737	* is a special type of object that casts swarms of other types	1719	* is a special type of object that casts swarms of other types
1738	* of spells. Which spell it casts is flexible. It fires the spells	1720	* of spells. Which spell it casts is flexible. It fires the spells
1739	* from a set of squares surrounding the caster, in a given direction.	1721	* from a set of squares surrounding the caster, in a given direction.
1740	*/	1722	*/
1741
1742	void	1723	void
1743	move_swarm_spell (object *op)	1724	move_swarm_spell (object *op)
1744	{	1725	{
1745	#if 0	1726	#if 0
1746	static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };	1727	static int cardinal_adjust[9] = { -3, -2, -1, 0, 0, 0, 1, 2, 3 };
1747	static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };	1728	static int diagonal_adjust[10] = { -3, -2, -2, -1, 0, 0, 1, 2, 2, 3 };
1748	sint16 target_x, target_y, origin_x, origin_y;	1729	sint16 target_x, target_y, origin_x, origin_y;
1749	int adjustdir;	1730	int adjustdir;
1750	maptile *m;	1731	maptile *m;
1751	#endif	1732	#endif
1752	int basedir;
1753	object *owner;	1733	object *owner = op->env;
1754		1734
1755	owner = op->owner;	1735	if (!owner) // MUST not happen, remove when true TODO
1756	if (op->duration == 0 \|\| owner == NULL)
1757	{	1736	{
		1737	LOG (llevError, "swarm spell found outside inventory: %s\n", op->debug_desc ());
1758	op->destroy ();	1738	op->destroy ();
1759	return;	1739	return;
1760	}	1740	}
1761		1741
		1742	if (!op->duration \|\| !owner->is_on_map ())
		1743	{
		1744	op->destroy ();
		1745	return;
		1746	}
		1747
1762	op->duration--;	1748	op->duration--;
1763		1749
1764	basedir = op->direction;	1750	int basedir = op->direction;
1765	if (basedir == 0)	1751	if (!basedir)
1766	{	1752	{
1767	/* spray in all directions! 8) */	1753	/* spray in all directions! 8) */
1768	basedir = rndm (1, 8);	1754	op->facing = (op->facing + op->state) & 7;
		1755	basedir = op->facing + 1;
1769	}	1756	}
1770		1757
1771	#if 0	1758	#if 0
1772	// this is bogus: it causes wrong places to be checked below	1759	// this is bogus: it causes wrong places to be checked below
1773	// (a wall 2 cells away will block the effect...) and	1760	// (a wall 2 cells away will block the effect...) and
…		…
1834	{	1821	{
1835	/* Bullet spells have a bunch more customization that needs to be done */	1822	/* Bullet spells have a bunch more customization that needs to be done */
1836	if (op->spell->subtype == SP_BULLET)	1823	if (op->spell->subtype == SP_BULLET)
1837	fire_bullet (owner, op, basedir, op->spell);	1824	fire_bullet (owner, op, basedir, op->spell);
1838	else if (op->spell->subtype == SP_MAGIC_MISSILE)	1825	else if (op->spell->subtype == SP_MAGIC_MISSILE)
1839	fire_arch_from_position (owner, op, op->x, op->y, basedir, op->spell);	1826	fire_arch_from_position (owner, op, owner->x, owner->y, basedir, op->spell);
1840	}	1827	}
1841	}	1828	}
1842
1843
1844
1845		1829
1846	/* fire_swarm:	1830	/* fire_swarm:
1847	* The following routine creates a swarm of objects. It actually	1831	* The following routine creates a swarm of objects. It actually
1848	* sets up a specific swarm object, which then fires off all	1832	* sets up a specific swarm object, which then fires off all
1849	* the parts of the swarm.	1833	* the parts of the swarm.
…		…
1852	* caster: the caster (owner, wand, rod, scroll)	1836	* caster: the caster (owner, wand, rod, scroll)
1853	* dir: the direction everything will be fired in	1837	* dir: the direction everything will be fired in
1854	* spell - the spell that is this spell.	1838	* spell - the spell that is this spell.
1855	* n: the number to be fired.	1839	* n: the number to be fired.
1856	*/	1840	*/
1857
1858	int	1841	int
1859	fire_swarm (object op, object caster, object *spell, int dir)	1842	fire_swarm (object op, object caster, object *spell, int dir)
1860	{	1843	{
1861	object *tmp;
1862	int i;
1863
1864	if (!spell->other_arch)	1844	if (!spell->other_arch)
1865	return 0;	1845	return 0;
1866		1846
1867	tmp = get_archetype (SWARM_SPELL);	1847	object *tmp = archetype::get (SWARM_SPELL);
1868	tmp->set_owner (op); /* needed so that if swarm elements kill, caster gets xp. */	1848
1869	set_spell_skill (op, caster, spell, tmp);	1849	set_spell_skill (op, caster, spell, tmp);
1870
1871	tmp->level = caster_level (caster, spell); /needed later, to get level dep. right. /	1850	tmp->level = caster_level (caster, spell); /* needed later, to get level dep. right. */
1872	tmp->spell = arch_to_object (spell->other_arch);	1851	tmp->spell = spell->other_arch->instance ();
1873
1874	tmp->attacktype = tmp->spell->attacktype;	1852	tmp->attacktype = tmp->spell->attacktype;
1875		1853
1876	if (tmp->attacktype & AT_HOLYWORD \|\| tmp->attacktype & AT_GODPOWER)	1854	if (tmp->attacktype & AT_HOLYWORD \|\| tmp->attacktype & AT_GODPOWER)
1877	if (!tailor_god_spell (tmp, op))	1855	if (!tailor_god_spell (tmp, op))
1878	return 1;	1856	return 1;
1879		1857
1880	tmp->duration = SP_level_duration_adjust (caster, spell);	1858	tmp->duration = SP_level_duration_adjust (caster, spell);
1881	for (i = 0; i < spell->duration; i++)	1859	for (int i = 0; i < spell->duration; i++)
1882	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);	1860	tmp->duration += die_roll (1, 3, op, PREFER_HIGH);
1883		1861
		1862	tmp->invisible = 1;
		1863	tmp->flag [FLAG_NO_DROP] = 1; // make sure it stays in inv, or else
1884	tmp->direction = dir;	1864	tmp->direction = dir;
1885	tmp->invisible = 1;	1865	tmp->facing = rndm (1, 8); // initial firing direction
		1866	tmp->state = rndm (4) * 2 + 1; // direction increment
1886		1867
1887	tmp->insert_at (op, op);	1868	op->insert (tmp);
		1869
1888	return 1;	1870	return 1;
1889	}	1871	}
1890
1891		1872
1892	/* See the spells documentation file for why this is its own	1873	/* See the spells documentation file for why this is its own
1893	* function.	1874	* function.
1894	*/	1875	*/
1895	int	1876	int
…		…
1926	if (QUERY_FLAG (target, FLAG_MONSTER))	1907	if (QUERY_FLAG (target, FLAG_MONSTER))
1927	{	1908	{
1928	/* oky doky. got a target monster. Lets make a blinding attack */	1909	/* oky doky. got a target monster. Lets make a blinding attack */
1929	if (target->head)	1910	if (target->head)
1930	target = target->head;	1911	target = target->head;
		1912
1931	(void) hit_player (target, dam, op, spell->attacktype, 1);	1913	hit_player (target, dam, op, spell->attacktype, 1);
1932	return 1; /* one success only! */	1914	return 1; /* one success only! */
1933	}	1915	}
1934	}	1916	}
1935		1917
1936	/* no live target, perhaps a wall is in the way? */	1918	/* no live target, perhaps a wall is in the way? */
…		…
1956	}	1938	}
1957		1939
1958	m->insert (tmp, x, y, op);	1940	m->insert (tmp, x, y, op);
1959	return 1;	1941	return 1;
1960	}	1942	}
1961
1962
1963
1964		1943
1965	/* cast_cause_disease: this spell looks along <dir> from the	1944	/* cast_cause_disease: this spell looks along <dir> from the
1966	* player and infects someone.	1945	* player and infects someone.
1967	* op is the player/monster, caster is the object, dir is the direction	1946	* op is the player/monster, caster is the object, dir is the direction
1968	* to cast, disease_arch is the specific disease, and type is the spell number	1947	* to cast, disease_arch is the specific disease, and type is the spell number
1969	* perhaps this should actually be in disease.c?	1948	* perhaps this should actually be in disease.c?
1970	*/	1949	*/
1971
1972	int	1950	int
1973	cast_cause_disease (object op, object caster, object *spell, int dir)	1951	cast_cause_disease (object op, object caster, object *spell, int dir)
1974	{	1952	{
1975	sint16 x, y;	1953	sint16 x, y;
1976	int i, mflags, range, dam_mod, dur_mod;	1954	int i, mflags, range, dam_mod, dur_mod;
…		…
1983	/* If casting from a scroll, no direction will be available, so refer to the	1961	/* If casting from a scroll, no direction will be available, so refer to the
1984	* direction the player is pointing.	1962	* direction the player is pointing.
1985	*/	1963	*/
1986	if (!dir)	1964	if (!dir)
1987	dir = op->facing;	1965	dir = op->facing;
		1966
1988	if (!dir)	1967	if (!dir)
1989	return 0; /* won't find anything if casting on ourself, so just return */	1968	return 0; /* won't find anything if casting on ourself, so just return */
1990		1969
1991	/* Calculate these once here */	1970	/* Calculate these once here */
1992	range = spell->range + SP_level_range_adjust (caster, spell);	1971	range = spell->range + SP_level_range_adjust (caster, spell);
…		…
2026	/* do level adjustments */	2005	/* do level adjustments */
2027	if (disease->stats.wc)	2006	if (disease->stats.wc)
2028	disease->stats.wc += dur_mod / 2;	2007	disease->stats.wc += dur_mod / 2;
2029		2008
2030	if (disease->magic > 0)	2009	if (disease->magic > 0)
2031	disease->magic += dur_mod / 4;	2010	disease->magic += dur_mod / 8;
2032		2011
2033	if (disease->stats.maxhp > 0)	2012	if (disease->stats.maxhp > 0)
2034	disease->stats.maxhp += dur_mod;	2013	disease->stats.maxhp += dur_mod;
2035		2014
2036	if (disease->stats.maxgrace > 0)	2015	if (disease->stats.maxgrace > 0)

Diff Legend

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

Comparing deliantra/server/server/spell_attack.C (file contents): Revision 1.44 by root, Sun Jul 22 14:17:58 2007 UTC vs. Revision 1.61 by root, Sun May 18 19:53:07 2008 UTC

Diff Legend

Comparing deliantra/server/server/spell_attack.C (file contents):
Revision 1.44 by root, Sun Jul 22 14:17:58 2007 UTC vs.
Revision 1.61 by root, Sun May 18 19:53:07 2008 UTC