ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/skills.C

Comparing deliantra/server/server/skills.C (file contents):
Revision 1.11 by root, Sat Sep 16 22:24:13 2006 UTC vs.
Revision 1.59 by elmex, Sun Dec 14 15:25:44 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 (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
4	Copyright (C) 2003 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2003,2007 Mark Wedel & Crossfire Development Team
5	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
6		7	*
7	This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
8	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
9	the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
10	(at your option) any later version.	11	* (at your option) any later version.
11		12	*
12	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,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	16	* GNU General Public License for more details.
16		17	*
17	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
18	along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	*
20		21	* The authors can be reached via e-mail to <support@deliantra.net>
21	The authors can be reached via e-mail to <crossfire@schmorp.de>
22	*/	22	*/
23		23
24	#include <global.h>	24	#include <global.h>
25	#include <object.h>	25	#include <object.h>
26	#ifndef __CEXTRACT__
27	# include <sproto.h>	26	#include <sproto.h>
28	#endif
29	#include <living.h>	27	#include <living.h>
30	#include <skills.h>	28	#include <skills.h>
31	#include <spells.h>	29	#include <spells.h>
32	#include <book.h>	30	#include <book.h>
33		31
…		…
41	return -1;	39	return -1;
42		40
43	/* Only prohibit stealing if the player does not have a free	41	/* Only prohibit stealing if the player does not have a free
44	* hand available and in fact does have hands.	42	* hand available and in fact does have hands.
45	*/	43	*/
46	if (op->type == PLAYER && op->body_used[BODY_ARMS] <= 0 && op->body_info[BODY_ARMS])	44	if (op->type == PLAYER && op->slot[body_arm].used <= 0 && op->slot[body_arm].info)
47	{	45	{
48	new_draw_info (NDI_UNIQUE, 0, op, "But you have no free hands to steal with!");	46	new_draw_info (NDI_UNIQUE, 0, op, "But you have no free hands to steal with!");
49	return -1;	47	return -1;
50	}	48	}
51		49
…		…
66	* it quite a bit harder to steal.	64	* it quite a bit harder to steal.
67	*/	65	*/
68	for (equip = op->inv; equip; equip = equip->below)	66	for (equip = op->inv; equip; equip = equip->below)
69	{	67	{
70	if (equip->type == WEAPON && QUERY_FLAG (equip, FLAG_APPLIED))	68	if (equip->type == WEAPON && QUERY_FLAG (equip, FLAG_APPLIED))
71	{
72	roll -= equip->weight / 10000;	69	roll -= equip->weight / 10000;
73	}	70
74	if (equip->type == BOW && QUERY_FLAG (equip, FLAG_APPLIED))	71	if (equip->type == BOW && QUERY_FLAG (equip, FLAG_APPLIED))
75	roll -= equip->weight / 5000;	72	roll -= equip->weight / 5000;
		73
76	if (equip->type == SHIELD && QUERY_FLAG (equip, FLAG_APPLIED))	74	if (equip->type == SHIELD && QUERY_FLAG (equip, FLAG_APPLIED))
77	{
78	roll -= equip->weight / 2000;	75	roll -= equip->weight / 2000;
79	}	76
80	if (equip->type == ARMOUR && QUERY_FLAG (equip, FLAG_APPLIED))	77	if (equip->type == ARMOUR && QUERY_FLAG (equip, FLAG_APPLIED))
81	roll -= equip->weight / 5000;	78	roll -= equip->weight / 5000;
		79
82	if (equip->type == GLOVES && QUERY_FLAG (equip, FLAG_APPLIED))	80	if (equip->type == GLOVES && QUERY_FLAG (equip, FLAG_APPLIED))
83	roll -= equip->weight / 100;	81	roll -= equip->weight / 100;
84	}	82	}
		83
85	if (roll < 0)	84	if (roll < 0)
86	roll = 0;	85	roll = 0;
		86
87	return roll;	87	return roll;
88	}	88	}
89		89
90	/*	90	/*
91	* When stealing: dependent on the intelligence/wisdom of whom you're	91	* When stealing: dependent on the intelligence/wisdom of whom you're
…		…
94	* or not.	94	* or not.
95	* op is the target (person being pilfered)	95	* op is the target (person being pilfered)
96	* who is the person doing the stealing.	96	* who is the person doing the stealing.
97	* skill is the skill object (stealing).	97	* skill is the skill object (stealing).
98	*/	98	*/
99
100	static int	99	static int
101	attempt_steal (object *op, object *who, object *skill)	100	attempt_steal (object *op, object *who, object *skill)
102	{	101	{
103	object *success = NULL, *tmp = NULL, *next;	102	object *success = NULL, *tmp = NULL, *next;
104	int roll = 0, chance = 0, stats_value;	103	int roll = 0, chance = 0, stats_value;
…		…
122	else /* help npc to detect thief next time by raising its wisdom */	121	else /* help npc to detect thief next time by raising its wisdom */
123	op->stats.Wis += (op->stats.Int / 5) + 1;	122	op->stats.Wis += (op->stats.Int / 5) + 1;
124	if (op->stats.Wis > MAX_STAT)	123	if (op->stats.Wis > MAX_STAT)
125	op->stats.Wis = MAX_STAT;	124	op->stats.Wis = MAX_STAT;
126	}	125	}
		126
127	if (op->type == PLAYER && QUERY_FLAG (op, FLAG_WIZ))	127	if (op->type == PLAYER && QUERY_FLAG (op, FLAG_WIZ))
128	{	128	{
129	new_draw_info (NDI_UNIQUE, 0, who, "You can't steal from the dungeon master!\n");	129	new_draw_info (NDI_UNIQUE, 0, who, "You can't steal from the dungeon master!\n");
130	return 0;	130	return 0;
131	}	131	}
132	#ifdef PROHIBIT_PLAYERKILL	132
		133	// only allow stealing between hostile players (TODO: probably should change)
133	if (op->type == PLAYER && who->type == PLAYER && (who->contr->peaceful || op->contr->peaceful))	134	if (op->type == PLAYER && who->type == PLAYER && (who->contr->peaceful || op->contr->peaceful))
134	{	135	{
135	new_draw_info (NDI_UNIQUE, 0, who, "You can't steal from other players!\n");	136	new_draw_info (NDI_UNIQUE, 0, who, "You can't steal from other players!\n");
136	return 0;	137	return 0;
137	}	138	}
138	#else
139	if (op->type == PLAYER && who->type == PLAYER && settings.no_player_stealing)
140	{
141	new_draw_info (NDI_UNIQUE, 0, who, "You can't steal from other players!\n");
142	return 0;
143	}
144	#endif
145		139
146
147	/* Ok then, go thru their inventory, stealing */	140	/* Ok then, go through their inventory, stealing */
148	for (tmp = op->inv; tmp != NULL; tmp = next)	141	for (tmp = op->inv; tmp; tmp = next)
149	{	142	{
150	next = tmp->below;	143	next = tmp->below;
151		144
152	/* you can't steal worn items, starting items, wiz stuff,	145	/* you can't steal worn items, starting items, wiz stuff,
153	* innate abilities, or items w/o a type. Generally	146	* innate abilities, or items w/o a type. Generally
…		…
157	* future possible problems. -b.t.	150	* future possible problems. -b.t.
158	* Flesh items generated w/ fix_flesh_item should have FLAG_NO_STEAL	151	* Flesh items generated w/ fix_flesh_item should have FLAG_NO_STEAL
159	* already -b.t.	152	* already -b.t.
160	*/	153	*/
161		154
162	if (QUERY_FLAG (tmp, FLAG_WAS_WIZ) || QUERY_FLAG (tmp, FLAG_APPLIED)	155	if (QUERY_FLAG (tmp, FLAG_APPLIED)
163	|| !(tmp->type)	156	|| !tmp->type
164	|| tmp->type == EXPERIENCE || tmp->type == SPELL	157	|| tmp->type == SPELL
165	|| QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_STEAL) || tmp->invisible)	158	|| QUERY_FLAG (tmp, FLAG_STARTEQUIP)
		159	|| QUERY_FLAG (tmp, FLAG_NO_STEAL)
		160	|| tmp->invisible)
166	continue;	161	continue;
167		162
168	/* Okay, try stealing this item. Dependent on dexterity of thief,	163	/* Okay, try stealing this item. Dependent on dexterity of thief,
169	* skill level, see the adj_stealroll fctn for more detail.	164	* skill level, see the adj_stealroll fctn for more detail.
170	*/	165	*/
…		…
184	if (tmp->destroyed () || tmp->env != op)	179	if (tmp->destroyed () || tmp->env != op)
185	{	180	{
186	/* for players, play_sound: steals item */	181	/* for players, play_sound: steals item */
187	success = tmp;	182	success = tmp;
188	CLEAR_FLAG (tmp, FLAG_INV_LOCKED);	183	CLEAR_FLAG (tmp, FLAG_INV_LOCKED);
189
190	/* Don't delete it from target player until we know
191	* the thief has picked it up. can't just look at tmp->count,
192	* as it's possible that it got merged when picked up.
193	*/
194	if (op->type == PLAYER)
195	esrv_del_item (op->contr, tmp->count);
196	}	184	}
		185
197	break;	186	break;
198	}	187	}
199	} /* for loop looking for an item */	188	} /* for loop looking for an item */
200		189
201	if (!tmp)	190	if (!tmp)
…		…
210	*/	199	*/
211		200
212	if ((roll >= skill->level) || !chance	201	if ((roll >= skill->level) || !chance
213	|| (tmp && tmp->weight > (250 * (random_roll (0, stats_value + skill->level * 10 - 1, who, PREFER_LOW)))))	202	|| (tmp && tmp->weight > (250 * (random_roll (0, stats_value + skill->level * 10 - 1, who, PREFER_LOW)))))
214	{	203	{
215
216	/* victim figures out where the thief is! */	204	/* victim figures out where the thief is! */
217	if (who->hide)	205	if (who->flag [FLAG_HIDDEN])
218	make_visible (who);	206	make_visible (who);
219		207
220	if (op->type != PLAYER)	208	if (op->type != PLAYER)
221	{	209	{
222	/* The unaggressives look after themselves 8) */	210	/* The unaggressives look after themselves 8) */
223	if (who->type == PLAYER)	211	if (who->type == PLAYER)
224	{	212	{
225	npc_call_help (op);	213	npc_call_help (op);
226	new_draw_info_format (NDI_UNIQUE, 0, who, "%s notices your attempted pilfering!", query_name (op));	214	new_draw_info_format (NDI_UNIQUE, 0, who, "%s notices your attempted pilfering!", query_name (op));
227	}	215	}
		216
228	CLEAR_FLAG (op, FLAG_UNAGGRESSIVE);	217	CLEAR_FLAG (op, FLAG_UNAGGRESSIVE);
229	/* all remaining npc items are guarded now. Set flag NO_STEAL	218	/* all remaining npc items are guarded now. Set flag NO_STEAL
230	* on the victim.	219	* on the victim.
231	*/	220	*/
232	SET_FLAG (op, FLAG_NO_STEAL);	221	SET_FLAG (op, FLAG_NO_STEAL);
…		…
235	{ /* stealing from another player */	224	{ /* stealing from another player */
236	char buf[MAX_BUF];	225	char buf[MAX_BUF];
237		226
238	/* Notify the other player */	227	/* Notify the other player */
239	if (success && who->stats.Int > random_roll (0, 19, op, PREFER_LOW))	228	if (success && who->stats.Int > random_roll (0, 19, op, PREFER_LOW))
240	{
241	sprintf (buf, "Your %s is missing!", query_name (success));	229	sprintf (buf, "Your %s is missing!", query_name (success));
242	}
243	else	230	else
244	{
245	sprintf (buf, "Your pack feels strangely lighter.");	231	sprintf (buf, "Your pack feels strangely lighter.");
246	}	232
247	new_draw_info (NDI_UNIQUE, 0, op, buf);	233	new_draw_info (NDI_UNIQUE, 0, op, buf);
248	if (!success)	234	if (!success)
249	{	235	{
250	if (who->invisible)	236	if (who->invisible)
251	{
252	sprintf (buf, "you feel itchy fingers getting at your pack.");	237	sprintf (buf, "you feel itchy fingers getting at your pack.");
253	}
254	else	238	else
255	{
256	sprintf (buf, "%s looks very shifty.", query_name (who));	239	sprintf (buf, "%s looks very shifty.", query_name (who));
257	}	240
258	new_draw_info (NDI_UNIQUE, 0, op, buf);	241	new_draw_info (NDI_UNIQUE, 0, op, buf);
259	}	242	}
260	} /* else stealing from another player */	243	} /* else stealing from another player */
261	/* play_sound("stop! thief!"); kindofthing */	244	/* play_sound("stop! thief!"); kindofthing */
262	} /* if you weren't 100% successful */	245	} /* if you weren't 100% successful */
		246
263	return success ? 1 : 0;	247	return success ? 1 : 0;
264	}	248	}
265
266		249
267	int	250	int
268	steal (object *op, int dir, object *skill)	251	steal (object *op, int dir, object *skill)
269	{	252	{
270	object *tmp, *next;	253	object *tmp, *next;
…		…
292	/* If player can't move onto the space, can't steal from it. */	275	/* If player can't move onto the space, can't steal from it. */
293	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))	276	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, x, y)))
294	return 0;	277	return 0;
295		278
296	/* Find the topmost object at this spot */	279	/* Find the topmost object at this spot */
297	for (tmp = get_map_ob (m, x, y); tmp != NULL && tmp->above != NULL; tmp = tmp->above);	280	for (tmp = GET_MAP_OB (m, x, y); tmp != NULL && tmp->above != NULL; tmp = tmp->above);
298		281
299	/* For all the stacked objects at this point, attempt a steal */	282	/* For all the stacked objects at this point, attempt a steal */
300	for (; tmp != NULL; tmp = next)	283	for (; tmp != NULL; tmp = next)
301	{	284	{
302	next = tmp->below;	285	next = tmp->below;
…		…
318	return 0;	301	return 0;
319		302
320	/* no xp for stealing from pets (of players) */	303	/* no xp for stealing from pets (of players) */
321	if (QUERY_FLAG (tmp, FLAG_FRIENDLY) && tmp->attack_movement == PETMOVE)	304	if (QUERY_FLAG (tmp, FLAG_FRIENDLY) && tmp->attack_movement == PETMOVE)
322	{	305	{
323	object *owner = get_owner (tmp);	306	object *owner = tmp->owner;
324		307
325	if (owner != NULL && owner->type == PLAYER)	308	if (owner != NULL && owner->type == PLAYER)
326	return 0;	309	return 0;
327	}	310	}
328		311
…		…
383	{	366	{
384	new_draw_info (NDI_UNIQUE, 0, pl, "There is no lock there.");	367	new_draw_info (NDI_UNIQUE, 0, pl, "There is no lock there.");
385	return 0;	368	return 0;
386	}	369	}
387		370
388	for (tmp = get_map_ob (pl->map, x, y); tmp; tmp = tmp->above)	371	for (tmp = GET_MAP_OB (pl->map, x, y); tmp; tmp = tmp->above)
389	if (tmp->type == DOOR || tmp->type == LOCKED_DOOR)	372	if (tmp->type == DOOR || tmp->type == LOCKED_DOOR)
390	break;	373	break;
391		374
392	if (!tmp)	375	if (!tmp)
393	{	376	{
…		…
415	{	398	{
416	new_draw_info (NDI_UNIQUE, 0, pl, "You fail to pick the lock.");	399	new_draw_info (NDI_UNIQUE, 0, pl, "You fail to pick the lock.");
417	return 0;	400	return 0;
418	}	401	}
419	}	402	}
420
421		403
422	/* HIDE CODE. The user becomes undetectable (not just 'invisible') for	404	/* HIDE CODE. The user becomes undetectable (not just 'invisible') for
423	* a short while (success and duration dependant on player SK_level,	405	* a short while (success and duration dependant on player SK_level,
424	* dexterity, charisma, and map difficulty).	406	* dexterity, charisma, and map difficulty).
425	* Players have a good chance of becoming 'unhidden' if they move	407	* Players have a good chance of becoming 'unhidden' if they move
426	* and like invisiblity will be come visible if they attack	408	* and like invisiblity will be come visible if they attack
427	* Implemented by b.t. (thomas@astro.psu.edu)	409	* Implemented by b.t. (thomas@astro.psu.edu)
428	* July 7, 1995 - made hiding possible for monsters. -b.t.	410	* July 7, 1995 - made hiding possible for monsters. -b.t.
429	*/	411	*/
430
431	static int	412	static int
432	attempt_hide (object *op, object *skill)	413	attempt_hide (object *op, object *skill)
433	{	414	{
434	int number, difficulty = op->map->difficulty;	415	int number, difficulty = op->map->difficulty;
435	int terrain = hideability (op);	416	int terrain = hideability (op);
…		…
438	return 0;	419	return 0;
439		420
440	/* Hiding success and duration dependant on skill level,	421	/* Hiding success and duration dependant on skill level,
441	* op->stats.Dex, map difficulty and terrain.	422	* op->stats.Dex, map difficulty and terrain.
442	*/	423	*/
443
444	number = (die_roll (2, 25, op, PREFER_LOW) - 2) / 2;	424	number = (die_roll (2, 25, op, PREFER_LOW) - 2) / 2;
		425
445	if (!stand_near_hostile (op) && (number < (op->stats.Dex + skill->level + terrain - difficulty)))	426	if (!stand_near_hostile (op) && (number < (op->stats.Dex + skill->level + terrain - difficulty)))
446	{	427	{
447	op->invisible += 100; /* set the level of 'hiddeness' */	428	op->invisible += 100; /* set the level of 'hiddeness' */
		429
448	if (op->type == PLAYER)	430	if (op->type == PLAYER)
449	op->contr->tmp_invis = 1;	431	op->contr->tmp_invis = 1;
450	op->hide = 1;	432
		433	op->flag [FLAG_HIDDEN] = 1;
451	return 1;	434	return 1;
452	}	435	}
		436
453	return 0;	437	return 0;
454	}	438	}
455		439
456	/* patched this to take terrain into consideration */	440	/* patched this to take terrain into consideration */
457	int	441	int
458	hide (object *op, object *skill)	442	hide (object *op, object *skill)
459	{	443	{
460
461	/* the preliminaries -- Can we really hide now? */	444	/* the preliminaries -- Can we really hide now? */
462	/* this keeps monsters from using invisibilty spells and hiding */	445	/* this keeps monsters from using invisibilty spells and hiding */
463		446
464	if (QUERY_FLAG (op, FLAG_MAKE_INVIS))	447	if (QUERY_FLAG (op, FLAG_MAKE_INVIS))
465	{	448	{
466	new_draw_info (NDI_UNIQUE, 0, op, "You don't need to hide while invisible!");	449	new_draw_info (NDI_UNIQUE, 0, op, "You don't need to hide while invisible!");
467	return 0;	450	return 0;
468	}	451	}
469	else if (!op->hide && op->invisible > 0 && op->type == PLAYER)	452	else if (!op->flag [FLAG_HIDDEN] && op->invisible > 0 && op->type == PLAYER)
470	{	453	{
471	new_draw_info (NDI_UNIQUE, 0, op, "Your attempt to hide breaks the invisibility spell!");	454	new_draw_info (NDI_UNIQUE, 0, op, "Your attempt to hide breaks the invisibility spell!");
472	make_visible (op);	455	make_visible (op);
473	}	456	}
474		457
475	if (op->invisible > (50 * skill->level))	458	if (op->invisible > 50 * skill->level)
476	{	459	{
477	new_draw_info (NDI_UNIQUE, 0, op, "You are as hidden as you can get.");	460	new_draw_info (NDI_UNIQUE, 0, op, "You are as hidden as you can get.");
478	return 0;	461	return 0;
479	}	462	}
480		463
…		…
482	{	465	{
483	new_draw_info (NDI_UNIQUE, 0, op, "You hide in the shadows.");	466	new_draw_info (NDI_UNIQUE, 0, op, "You hide in the shadows.");
484	update_object (op, UP_OBJ_FACE);	467	update_object (op, UP_OBJ_FACE);
485	return calc_skill_exp (op, NULL, skill);	468	return calc_skill_exp (op, NULL, skill);
486	}	469	}
		470
487	new_draw_info (NDI_UNIQUE, 0, op, "You fail to conceal yourself.");	471	new_draw_info (NDI_UNIQUE, 0, op, "You fail to conceal yourself.");
488	return 0;	472	return 0;
489	}	473	}
490
491		474
492	/* stop_jump() - End of jump. Clear flags, restore the map, and	475	/* stop_jump() - End of jump. Clear flags, restore the map, and
493	* freeze the jumper a while to simulate the exhaustion	476	* freeze the jumper a while to simulate the exhaustion
494	* of jumping.	477	* of jumping.
495	*/	478	*/
496	static void	479	static void
497	stop_jump (object *pl, int dist, int spaces)	480	stop_jump (object *pl, int dist, int spaces)
498	{	481	{
499	fix_player (pl);	482	pl->update_stats ();
500	insert_ob_in_map (pl, pl->map, pl, 0);	483	pl->map->insert (pl, pl->x, pl->y, pl);
		484	pl->speed_left -= fabs (pl->speed * 8);
501	}	485	}
502
503		486
504	static int	487	static int
505	attempt_jump (object *pl, int dir, int spaces, object *skill)	488	attempt_jump (object *pl, int dir, int spaces, object *skill)
506	{	489	{
507	object *tmp;	490	object *tmp;
508	int i, exp = 0, dx = freearr_x[dir], dy = freearr_y[dir], mflags;	491	int i, dx = freearr_x[dir], dy = freearr_y[dir], mflags;
509	sint16 x, y;	492	sint16 x, y;
510	maptile *m;	493	maptile *m;
511		494
512	/* Jump loop. Go through spaces opject wants to jump. Halt the	495	/* Jump loop. Go through spaces object wants to jump. Halt the
513	* jump if a wall or creature is in the way. We set FLAG_FLYING	496	* jump if a wall or creature is in the way. We set FLAG_FLYING
514	* temporarily to allow player to aviod exits/archs that are not	497	* temporarily to allow player to aviod exits/archs that are not
515	* fly_on, fly_off. This will also prevent pickup of objects	498	* fly_on, fly_off. This will also prevent pickup of objects
516	* while jumping over them.	499	* while jumping over them.
517	*/	500	*/
518		501	pl->remove ();
519	remove_ob (pl);
520
521	/*
522	* I don't think this is actually needed - all the movement
523	* code is handled in this function, and I don't see anyplace
524	* that cares about the move_type being flying.
525	*/
526	pl->move_type |= MOVE_FLY_LOW;	502	pl->move_type |= MOVE_FLY_LOW;
527		503
528	for (i = 0; i <= spaces; i++)	504	for (i = 0; i <= spaces; i++)
529	{	505	{
530	x = pl->x + dx;	506	x = pl->x + dx;
…		…
533		509
534	mflags = get_map_flags (m, &m, x, y, &x, &y);	510	mflags = get_map_flags (m, &m, x, y, &x, &y);
535		511
536	if (mflags & P_OUT_OF_MAP)	512	if (mflags & P_OUT_OF_MAP)
537	{	513	{
538	(void) stop_jump (pl, i, spaces);	514	stop_jump (pl, i, spaces);
539	return 0;	515	return 0;
540	}	516	}
		517
		518	for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
		519	{
		520	/* Jump into creature */
		521	if (QUERY_FLAG (tmp, FLAG_MONSTER)
		522	|| (tmp->type == PLAYER && (!QUERY_FLAG (tmp, FLAG_WIZ) || !tmp->contr->hidden)))
		523	{
		524	new_draw_info_format (NDI_UNIQUE, 0, pl, "You jump into %s%s.", tmp->type == PLAYER ? "" : "the ", &tmp->name);
		525
		526	stop_jump (pl, i, spaces);
		527
		528	int exp = 0;
		529
		530	if (tmp->type != PLAYER
		531	|| (pl->type == PLAYER && !pl->contr->party)
		532	|| (pl->type == PLAYER && tmp->type == PLAYER && pl->contr->party != tmp->contr->party))
		533	exp = skill_attack (tmp, pl, pl->facing, "kicked", skill); /* pl makes an attack */
		534
		535	return exp; /* note that calc_skill_exp() is already called by skill_attack() */
		536	}
		537	}
		538
541	if (OB_TYPE_MOVE_BLOCK (pl, GET_MAP_MOVE_BLOCK (m, x, y)))	539	if (OB_TYPE_MOVE_BLOCK (pl, GET_MAP_MOVE_BLOCK (m, x, y)))
542	{	540	{
543	new_draw_info (NDI_UNIQUE, 0, pl, "Your jump is blocked.");	541	new_draw_info (NDI_UNIQUE, 0, pl, "Your jump is blocked.");
544	stop_jump (pl, i, spaces);	542	stop_jump (pl, i, spaces);
545	return 0;	543	return 0;
546	}	544	}
547		545
548	for (tmp = get_map_ob (m, x, y); tmp; tmp = tmp->above)
549	{
550	/* Jump into creature */
551	if (QUERY_FLAG (tmp, FLAG_MONSTER) || (tmp->type == PLAYER && (!QUERY_FLAG (tmp, FLAG_WIZ) || !tmp->contr->hidden)))
552	{
553	new_draw_info_format (NDI_UNIQUE, 0, pl, "You jump into %s%s.", tmp->type == PLAYER ? "" : "the ", &tmp->name);
554	if (tmp->type != PLAYER ||
555	(pl->type == PLAYER && pl->contr->party == NULL) ||
556	(pl->type == PLAYER && tmp->type == PLAYER && pl->contr->party != tmp->contr->party))
557	exp = skill_attack (tmp, pl, pl->facing, "kicked", skill); /* pl makes an attack */
558	stop_jump (pl, i, spaces);
559	return exp; /* note that calc_skill_exp() is already called by skill_attack() */
560	}
561	/* If the space has fly on set (no matter what the space is),
562	* we should get the effects - after all, the player is
563	* effectively flying.
564	*/
565	if (tmp->move_on & MOVE_FLY_LOW)
566	{
567	pl->x = x;
568	pl->y = y;
569	pl->map = m;
570	stop_jump (pl, i, spaces);
571	return calc_skill_exp (pl, NULL, skill);
572	}
573	}
574	pl->x = x;	546	pl->x = x;
575	pl->y = y;	547	pl->y = y;
576	pl->map = m;	548	pl->map = m;
		549
		550	if (m->at (x, y).move_on & pl->move_type)
		551	{
		552	new_draw_info (NDI_UNIQUE, 0, pl, "Your jump is stopped.");
		553	stop_jump (pl, i, spaces);
		554	return 0;
		555	}
577	}	556	}
		557
578	stop_jump (pl, i, spaces);	558	stop_jump (pl, i, spaces);
		559
579	return calc_skill_exp (pl, NULL, skill);	560	return calc_skill_exp (pl, NULL, skill);
580	}	561	}
581		562
582	/* jump() - this is both a new type of movement for player/monsters and	563	/* jump() - this is both a new type of movement for player/monsters and
583	* an attack as well.	564	* an attack as well.
584	* Perhaps we should allow more spaces based on level, eg, level 50	565	* Perhaps we should allow more spaces based on level, eg, level 50
585	* jumper can jump several spaces?	566	* jumper can jump several spaces?
586	*/	567	*/
587
588	int	568	int
589	jump (object *pl, int dir, object *skill)	569	jump (object *pl, int dir, object *skill)
590	{	570	{
591	int spaces = 0, stats;
592	int str = pl->stats.Str;	571	int str = pl->stats.Str;
593	int dex = pl->stats.Dex;	572	int dex = pl->stats.Dex;
594		573
595	dex = dex ? dex : 15;	574	dex = dex ? dex : 15;
596	str = str ? str : 10;	575	str = str ? str : 10;
597		576
598	stats = str * str * str * dex * skill->level;	577	int stats = str * str * str * dex * skill->level;
		578	int spaces = min (3, skill->level, stats / (pl->carrying + 1));
599		579
600	if (pl->carrying != 0) /* don't want div by zero !! */
601	spaces = (int) (stats / pl->carrying);
602	else
603	spaces = 2; /* pl has no objects - gets the far jump */
604
605	if (spaces > 2)
606	spaces = 2;
607	else if (spaces == 0)	580	if (spaces == 0)
608	{	581	{
609	new_draw_info (NDI_UNIQUE, 0, pl, "You are carrying too much weight to jump.");	582	new_draw_info (NDI_UNIQUE, 0, pl, "You are carrying too much weight to jump.");
610	return 0;	583	return 0;
611	}	584	}
		585
612	return attempt_jump (pl, dir, spaces, skill);	586	return attempt_jump (pl, dir, spaces, skill);
613	}	587	}
614
615		588
616	/* skill_ident() - this code is supposed to allow players to identify	589	/* skill_ident() - this code is supposed to allow players to identify
617	* classes of objects with the various "auto-ident" skills. Player must	590	* classes of objects with the various "auto-ident" skills. Player must
618	* have unidentified objects of the right type in order for the skill	591	* have unidentified objects of the right type in order for the skill
619	* to work. While multiple classes of objects may be identified,	592	* to work. While multiple classes of objects may be identified,
620	* this code is kind of yucky -- it would be nice to make it a bit	593	* this code is kind of yucky -- it would be nice to make it a bit
621	* more generalized. Right now, skill indices are embedded in this routine.	594	* more generalized. Right now, skill indices are embedded in this routine.
622	* Returns amount of experience gained (on successful ident).	595	* Returns amount of experience gained (on successful ident).
623	* - b.t. (thomas@astro.psu.edu)	596	* - b.t. (thomas@astro.psu.edu)
624	*/	597	*/
625
626	static int	598	static int
627	do_skill_detect_curse (object *pl, object *skill)	599	do_skill_detect_curse (object *pl, object *skill)
628	{	600	{
629	object *tmp;	601	object *tmp;
630	int success = 0;	602	int success = 0;
…		…
638	esrv_update_item (UPD_FLAGS, pl, tmp);	610	esrv_update_item (UPD_FLAGS, pl, tmp);
639	success += calc_skill_exp (pl, tmp, skill);	611	success += calc_skill_exp (pl, tmp, skill);
640	}	612	}
641		613
642	/* Check ground, too, but only objects the player could pick up */	614	/* Check ground, too, but only objects the player could pick up */
643	for (tmp = get_map_ob (pl->map, pl->x, pl->y); tmp; tmp = tmp->above)	615	for (tmp = GET_MAP_OB (pl->map, pl->x, pl->y); tmp; tmp = tmp->above)
644	if (can_pick (pl, tmp) &&	616	if (can_pick (pl, tmp) &&
645	!QUERY_FLAG (tmp, FLAG_IDENTIFIED) &&	617	!QUERY_FLAG (tmp, FLAG_IDENTIFIED) &&
646	!QUERY_FLAG (tmp, FLAG_KNOWN_CURSED)	618	!QUERY_FLAG (tmp, FLAG_KNOWN_CURSED)
647	&& (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)) && tmp->item_power < skill->level)	619	&& (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)) && tmp->item_power < skill->level)
648	{	620	{
…		…
669	esrv_update_item (UPD_FLAGS, pl, tmp);	641	esrv_update_item (UPD_FLAGS, pl, tmp);
670	success += calc_skill_exp (pl, tmp, skill);	642	success += calc_skill_exp (pl, tmp, skill);
671	}	643	}
672		644
673	/* Check ground, too, but like above, only if the object can be picked up */	645	/* Check ground, too, but like above, only if the object can be picked up */
674	for (tmp = get_map_ob (pl->map, pl->x, pl->y); tmp; tmp = tmp->above)	646	for (tmp = GET_MAP_OB (pl->map, pl->x, pl->y); tmp; tmp = tmp->above)
675	if (can_pick (pl, tmp) &&	647	if (can_pick (pl, tmp) &&
676	!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && (is_magical (tmp)) && tmp->item_power < skill->level)	648	!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && (is_magical (tmp)) && tmp->item_power < skill->level)
677	{	649	{
678	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);	650	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
679	esrv_update_item (UPD_FLAGS, pl, tmp);	651	esrv_update_item (UPD_FLAGS, pl, tmp);
…		…
708	if (tmp->msg)	680	if (tmp->msg)
709	{	681	{
710	new_draw_info (NDI_UNIQUE, 0, pl, "The item has a story:");	682	new_draw_info (NDI_UNIQUE, 0, pl, "The item has a story:");
711	new_draw_info (NDI_UNIQUE, 0, pl, tmp->msg);	683	new_draw_info (NDI_UNIQUE, 0, pl, tmp->msg);
712	}	684	}
713
714	/* identify will take care of updating the item if it is in the players inventory. IF on map, do it here */
715	if (tmp->map)
716	esrv_send_item (pl, tmp);
717	}	685	}
		686
718	success += calc_skill_exp (pl, tmp, skill);	687	success += calc_skill_exp (pl, tmp, skill);
719	}	688	}
720	else	689	else
721	SET_FLAG (tmp, FLAG_NO_SKILL_IDENT);	690	SET_FLAG (tmp, FLAG_NO_SKILL_IDENT);
722	}	691	}
…		…
727	/* do_skill_ident() - workhorse for skill_ident() -b.t.	696	/* do_skill_ident() - workhorse for skill_ident() -b.t.
728	*/	697	*/
729	static int	698	static int
730	do_skill_ident (object *pl, int obj_class, object *skill)	699	do_skill_ident (object *pl, int obj_class, object *skill)
731	{	700	{
732	object *tmp;
733	int success = 0;	701	int success = 0;
734		702
735	for (tmp = pl->inv; tmp; tmp = tmp->below)	703	for (object *tmp = pl->inv; tmp; tmp = tmp->below)
736	success += do_skill_ident2 (tmp, pl, obj_class, skill);	704	success += do_skill_ident2 (tmp, pl, obj_class, skill);
737	/* check the ground */	705	/* check the ground */
738		706
739	for (tmp = get_map_ob (pl->map, pl->x, pl->y); tmp; tmp = tmp->above)	707	for (object *tmp = pl->ms ().bot; tmp; tmp = tmp->above)
740	success += do_skill_ident2 (tmp, pl, obj_class, skill);	708	success += do_skill_ident2 (tmp, pl, obj_class, skill);
741		709
742	return success;	710	return success;
743	}	711	}
744		712
…		…
752		720
753	new_draw_info (NDI_UNIQUE, 0, pl, "You look at the objects nearby...");	721	new_draw_info (NDI_UNIQUE, 0, pl, "You look at the objects nearby...");
754		722
755	switch (skill->subtype)	723	switch (skill->subtype)
756	{	724	{
757	case SK_SMITHERY:	725	case SK_SMITHERY:
758	success += do_skill_ident (pl, WEAPON, skill) + do_skill_ident (pl, ARMOUR, skill)	726	success += do_skill_ident (pl, WEAPON, skill) + do_skill_ident (pl, ARMOUR, skill)
759	+ do_skill_ident (pl, BRACERS, skill) + do_skill_ident (pl, CLOAK, skill)	727	+ do_skill_ident (pl, BRACERS, skill) + do_skill_ident (pl, CLOAK, skill)
760	+ do_skill_ident (pl, BOOTS, skill) + do_skill_ident (pl, SHIELD, skill)	728	+ do_skill_ident (pl, BOOTS, skill) + do_skill_ident (pl, SHIELD, skill)
761	+ do_skill_ident (pl, GIRDLE, skill) + do_skill_ident (pl, HELMET, skill) + do_skill_ident (pl, GLOVES, skill);	729	+ do_skill_ident (pl, GIRDLE, skill) + do_skill_ident (pl, HELMET, skill) + do_skill_ident (pl, GLOVES, skill);
762	break;	730	break;
763		731
764	case SK_BOWYER:	732	case SK_BOWYER:
765	success += do_skill_ident (pl, BOW, skill) + do_skill_ident (pl, ARROW, skill);	733	success += do_skill_ident (pl, BOW, skill) + do_skill_ident (pl, ARROW, skill);
766	break;	734	break;
767		735
768	case SK_ALCHEMY:	736	case SK_ALCHEMY:
769	success += do_skill_ident (pl, POTION, skill) + do_skill_ident (pl, POISON, skill)	737	success += do_skill_ident (pl, POTION, skill) + do_skill_ident (pl, POISON, skill)
770	+ do_skill_ident (pl, CONTAINER, skill) + do_skill_ident (pl, DRINK, skill) + do_skill_ident (pl, INORGANIC, skill);	738	+ do_skill_ident (pl, CONTAINER, skill) + do_skill_ident (pl, DRINK, skill) + do_skill_ident (pl, INORGANIC, skill);
771	break;	739	break;
772		740
773	case SK_WOODSMAN:	741	case SK_WOODSMAN:
774	success += do_skill_ident (pl, FOOD, skill) + do_skill_ident (pl, DRINK, skill) + do_skill_ident (pl, FLESH, skill);	742	success += do_skill_ident (pl, FOOD, skill) + do_skill_ident (pl, DRINK, skill) + do_skill_ident (pl, FLESH, skill);
775	break;	743	break;
776		744
777	case SK_JEWELER:	745	case SK_JEWELER:
778	success += do_skill_ident (pl, GEM, skill) + do_skill_ident (pl, RING, skill) + do_skill_ident (pl, AMULET, skill);	746	success += do_skill_ident (pl, GEM, skill) + do_skill_ident (pl, RING, skill) + do_skill_ident (pl, AMULET, skill);
779	break;	747	break;
780		748
781	case SK_LITERACY:	749	case SK_LITERACY:
782	success += do_skill_ident (pl, SPELLBOOK, skill) + do_skill_ident (pl, SCROLL, skill) + do_skill_ident (pl, BOOK, skill);	750	success += do_skill_ident (pl, SPELLBOOK, skill) + do_skill_ident (pl, SCROLL, skill) + do_skill_ident (pl, BOOK, skill);
783	break;	751	break;
784		752
785	case SK_THAUMATURGY:	753	case SK_THAUMATURGY:
786	success += do_skill_ident (pl, WAND, skill) + do_skill_ident (pl, ROD, skill) + do_skill_ident (pl, HORN, skill);	754	success += do_skill_ident (pl, WAND, skill) + do_skill_ident (pl, ROD, skill) + do_skill_ident (pl, HORN, skill);
787	break;	755	break;
788		756
789	case SK_DET_CURSE:	757	case SK_DET_CURSE:
790	success = do_skill_detect_curse (pl, skill);	758	success = do_skill_detect_curse (pl, skill);
791	if (success)	759	if (success)
792	new_draw_info (NDI_UNIQUE, 0, pl, "...and discover cursed items!");	760	new_draw_info (NDI_UNIQUE, 0, pl, "...and discover cursed items!");
793	break;	761	break;
794		762
795	case SK_DET_MAGIC:	763	case SK_DET_MAGIC:
796	success = do_skill_detect_magic (pl, skill);	764	success = do_skill_detect_magic (pl, skill);
797	if (success)	765	if (success)
798	new_draw_info (NDI_UNIQUE, 0, pl, "...and discover items imbued with mystic forces!");	766	new_draw_info (NDI_UNIQUE, 0, pl, "...and discover items imbued with mystic forces!");
799	break;	767	break;
800		768
801	default:	769	default:
802	LOG (llevError, "Error: bad call to skill_ident()\n");	770	LOG (llevError, "Error: bad call to skill_ident()\n");
803	return 0;	771	return 0;
804	break;	772	break;
805	}	773	}
		774
806	if (!success)	775	if (!success)
807	{
808	new_draw_info (NDI_UNIQUE, 0, pl, "...and learn nothing more.");	776	new_draw_info (NDI_UNIQUE, 0, pl, "...and learn nothing more.");
809	}	777
810	return success;	778	return success;
811	}	779	}
812
813		780
814	/* players using this skill can 'charm' a monster --	781	/* players using this skill can 'charm' a monster --
815	* into working for them. It can only be used on	782	* into working for them. It can only be used on
816	* non-special (see below) 'neutral' creatures.	783	* non-special (see below) 'neutral' creatures.
817	* -b.t. (thomas@astro.psu.edu)	784	* -b.t. (thomas@astro.psu.edu)
818	*/	785	*/
819
820	int	786	int
821	use_oratory (object *pl, int dir, object *skill)	787	use_oratory (object *pl, int dir, object *skill)
822	{	788	{
823	sint16 x = pl->x + freearr_x[dir], y = pl->y + freearr_y[dir];
824	int mflags, chance;
825	object *tmp;
826	maptile *m;
827
828	if (pl->type != PLAYER)	789	if (pl->type != PLAYER)
829	return 0; /* only players use this skill */	790	return 0; /* only players use this skill */
		791
		792	sint16 x = pl->x + freearr_x[dir],
		793	y = pl->y + freearr_y[dir];
830	m = pl->map;	794	maptile *m = pl->map;
		795
831	mflags = get_map_flags (m, &m, x, y, &x, &y);	796	int mflags = get_map_flags (m, &m, x, y, &x, &y);
832	if (mflags & P_OUT_OF_MAP)	797	if (mflags & P_OUT_OF_MAP)
833	return 0;	798	return 0;
834		799
835	/* Save some processing - we have the flag already anyways	800	/* Save some processing - we have the flag already anyways
836	*/	801	*/
…		…
838	{	803	{
839	new_draw_info (NDI_UNIQUE, 0, pl, "There is nothing to orate to.");	804	new_draw_info (NDI_UNIQUE, 0, pl, "There is nothing to orate to.");
840	return 0;	805	return 0;
841	}	806	}
842		807
		808	object *tmp;
843	for (tmp = get_map_ob (m, x, y); tmp; tmp = tmp->above)	809	for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
844	{	810	{
845	/* can't persuade players - return because there is nothing else	811	/* can't persuade players - return because there is nothing else
846	* on that space to charm. Same for multi space monsters and	812	* on that space to charm. Same for multi space monsters and
847	* special monsters - we don't allow them to be charmed, and there	813	* special monsters - we don't allow them to be charmed, and there
848	* is no reason to do further processing since they should be the	814	* is no reason to do further processing since they should be the
849	* only monster on the space.	815	* only monster on the space.
850	*/	816	*/
851	if (tmp->type == PLAYER)	817	if (tmp->type == PLAYER
852	return 0;	818	|| tmp->more || tmp->head_ () != tmp
853	if (tmp->more || tmp->head)	819	|| tmp->msg)
854	return 0;
855	if (tmp->msg)
856	return 0;	820	return 0;
857		821
858	if (QUERY_FLAG (tmp, FLAG_MONSTER))	822	if (QUERY_FLAG (tmp, FLAG_MONSTER))
859	break;	823	break;
860	}	824	}
…		…
875	new_draw_info_format (NDI_UNIQUE, 0, pl, "Too bad the %s isn't listening!\n", query_name (tmp));	839	new_draw_info_format (NDI_UNIQUE, 0, pl, "Too bad the %s isn't listening!\n", query_name (tmp));
876	return 0;	840	return 0;
877	}	841	}
878		842
879	/* it's already allied! */	843	/* it's already allied! */
880	if (QUERY_FLAG (tmp, FLAG_FRIENDLY) && (tmp->attack_movement == PETMOVE))	844	if (QUERY_FLAG (tmp, FLAG_FRIENDLY) && tmp->attack_movement == PETMOVE)
881	{	845	{
882	if (get_owner (tmp) == pl)	846	if (tmp->owner == pl)
883	{	847	{
884	new_draw_info (NDI_UNIQUE, 0, pl, "Your follower loves your speech.\n");	848	new_draw_info (NDI_UNIQUE, 0, pl, "Your follower loves your speech.\n");
885	return 0;	849	return 0;
886	}	850	}
887	else if (skill->level > tmp->level)	851	else if (skill->level > tmp->level)
888	{	852	{
889	/* you steal the follower. Perhaps we should really look at the	853	/* you steal the follower. Perhaps we should really look at the
890	* level of the owner above?	854	* level of the owner above?
891	*/	855	*/
892	set_owner (tmp, pl);	856	tmp->set_owner (pl);
		857	tmp->skill = skill->skill;
		858
893	new_draw_info_format (NDI_UNIQUE, 0, pl, "You convince the %s to follow you instead!\n", query_name (tmp));	859	new_draw_info_format (NDI_UNIQUE, 0, pl, "You convince the %s to follow you instead!\n", query_name (tmp));
894	/* Abuse fix - don't give exp since this can otherwise	860	/* Abuse fix - don't give exp since this can otherwise
895	* be used by a couple players to gets lots of exp.	861	* be used by a couple players to gets lots of exp.
896	*/	862	*/
897	return 0;	863	return 0;
…		…
901	/* In this case, you can't steal it from the other player */	867	/* In this case, you can't steal it from the other player */
902	return 0;	868	return 0;
903	}	869	}
904	} /* Creature was already a pet of someone */	870	} /* Creature was already a pet of someone */
905		871
906	chance = skill->level * 2 + (pl->stats.Cha - 2 * tmp->stats.Int) / 2;	872	int level = skill->level + (pl->stats.Cha - tmp->stats.Int) / 2;
907		873
908	/* Ok, got a 'sucker' lets try to make them a follower */	874	/* Ok, got a 'sucker' lets try to make them a follower */
909	if (chance > 0 && tmp->level < (random_roll (0, chance - 1, pl, PREFER_HIGH) - 1))	875	if (level > 0 && tmp->level < (random_roll (0, level - 1, pl, PREFER_HIGH) - 1))
910	{	876	{
911	new_draw_info_format (NDI_UNIQUE, 0, pl, "You convince the %s to become your follower.\n", query_name (tmp));	877	new_draw_info_format (NDI_UNIQUE, 0, pl, "You convince the %s to become your follower.\n", query_name (tmp));
912		878
		879	INVOKE_OBJECT (KILL, tmp, ARG_OBJECT (pl));
913	set_owner (tmp, pl);	880	tmp->set_owner (pl);
		881	tmp->skill = skill->skill;
914	tmp->stats.exp = 0;	882	tmp->stats.exp = 0;
915	add_friendly_object (tmp);
916	SET_FLAG (tmp, FLAG_FRIENDLY);
917	tmp->attack_movement = PETMOVE;	883	tmp->attack_movement = PETMOVE;
		884
		885	if (!QUERY_FLAG (tmp, FLAG_FRIENDLY))
		886	add_friendly_object (tmp);
		887
918	return calc_skill_exp (pl, tmp, skill);	888	return calc_skill_exp (pl, tmp, skill);
919	}	889	}
920	/* Charm failed. Creature may be angry now */	890	/* Charm failed. Creature may be angry now */
921	else if ((skill->level + ((pl->stats.Cha - 10) / 2)) < random_roll (1, 2 * tmp->level, pl, PREFER_LOW))	891	else if ((skill->level + ((pl->stats.Cha - 10) / 2)) < random_roll (1, 2 * tmp->level, pl, PREFER_LOW))
922	{	892	{
923	new_draw_info_format (NDI_UNIQUE, 0, pl, "Your speech angers the %s!\n", query_name (tmp));	893	new_draw_info_format (NDI_UNIQUE, 0, pl, "Your speech angers the %s!\n", query_name (tmp));
924	if (QUERY_FLAG (tmp, FLAG_FRIENDLY))	894	if (QUERY_FLAG (tmp, FLAG_FRIENDLY))
925	{	895	{
926	CLEAR_FLAG (tmp, FLAG_FRIENDLY);
927	remove_friendly_object (tmp);	896	remove_friendly_object (tmp);
928	tmp->attack_movement = 0; /* needed? */	897	tmp->attack_movement = 0; /* needed? */
929	}	898	}
		899
930	CLEAR_FLAG (tmp, FLAG_UNAGGRESSIVE);	900	CLEAR_FLAG (tmp, FLAG_UNAGGRESSIVE);
931	}	901	}
		902
932	return 0; /* Fall through - if we get here, we didn't charm anything */	903	return 0; /* Fall through - if we get here, we didn't charm anything */
933	}	904	}
934		905
935	/* Singing() -this skill allows the player to pacify nearby creatures.	906	/* Singing() -this skill allows the player to pacify nearby creatures.
936	* There are few limitations on who/what kind of	907	* There are few limitations on who/what kind of
…		…
939	* successfully pacified the creature gets Int=1. Thus, a player	910	* successfully pacified the creature gets Int=1. Thus, a player
940	* may only pacify a creature once.	911	* may only pacify a creature once.
941	* BTW, I appologize for the naming of the skill, I couldnt think	912	* BTW, I appologize for the naming of the skill, I couldnt think
942	* of anything better! -b.t.	913	* of anything better! -b.t.
943	*/	914	*/
944
945	int	915	int
946	singing (object *pl, int dir, object *skill)	916	singing (object *pl, int dir, object *skill)
947	{	917	{
948	int i, exp = 0, chance, mflags;	918	int i, exp = 0;
949	object *tmp;	919	object *tmp;
950	maptile *m;	920	maptile *m;
951	sint16 x, y;	921	sint16 x, y;
952		922
953	if (pl->type != PLAYER)	923	if (pl->type != PLAYER)
…		…
958	{	928	{
959	x = pl->x + freearr_x[i];	929	x = pl->x + freearr_x[i];
960	y = pl->y + freearr_y[i];	930	y = pl->y + freearr_y[i];
961	m = pl->map;	931	m = pl->map;
962		932
963	mflags = get_map_flags (m, &m, x, y, &x, &y);	933	int mflags = get_map_flags (m, &m, x, y, &x, &y);
964	if (mflags & P_OUT_OF_MAP)	934	if (mflags & P_OUT_OF_MAP)
965	continue;	935	continue;
966	if (!(mflags & P_IS_ALIVE))	936	if (!(mflags & P_IS_ALIVE))
967	continue;	937	continue;
968		938
969	for (tmp = get_map_ob (m, x, y); tmp; tmp = tmp->above)	939	for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
970	{	940	{
971	if (QUERY_FLAG (tmp, FLAG_MONSTER))	941	if (QUERY_FLAG (tmp, FLAG_MONSTER))
972	break;	942	break;
973	/* can't affect players */	943	/* can't affect players */
974	if (tmp->type == PLAYER)	944	if (tmp->type == PLAYER)
…		…
987		957
988	/* stealing isn't really related (although, maybe it should	958	/* stealing isn't really related (although, maybe it should
989	* be). This is mainly to prevent singing to the same monster	959	* be). This is mainly to prevent singing to the same monster
990	* over and over again and getting exp for it.	960	* over and over again and getting exp for it.
991	*/	961	*/
992	chance = skill->level * 2 + (pl->stats.Cha - 5 - tmp->stats.Int) / 2;	962	int level = skill->level + (pl->stats.Cha - 5 - tmp->stats.Int) / 2;
		963
993	if (chance && tmp->level * 2 < random_roll (0, chance - 1, pl, PREFER_HIGH))	964	if (level && tmp->level < random_roll (0, level - 1, pl, PREFER_HIGH))
994	{	965	{
995	SET_FLAG (tmp, FLAG_UNAGGRESSIVE);	966	SET_FLAG (tmp, FLAG_UNAGGRESSIVE);
996	new_draw_info_format (NDI_UNIQUE, 0, pl, "You calm down the %s\n", query_name (tmp));	967	new_draw_info_format (NDI_UNIQUE, 0, pl, "You calm down the %s\n", query_name (tmp));
997	/* Give exp only if they are not aware */	968	/* Give exp only if they are not aware */
		969
998	if (!QUERY_FLAG (tmp, FLAG_NO_STEAL))	970	if (!QUERY_FLAG (tmp, FLAG_NO_STEAL))
999	exp += calc_skill_exp (pl, tmp, skill);	971	exp += calc_skill_exp (pl, tmp, skill);
		972
1000	SET_FLAG (tmp, FLAG_NO_STEAL);	973	SET_FLAG (tmp, FLAG_NO_STEAL);
1001	}	974	}
1002	else	975	else
1003	{	976	{
1004	new_draw_info_format (NDI_UNIQUE, 0, pl, "Too bad the %s isn't listening!\n", query_name (tmp));	977	new_draw_info_format (NDI_UNIQUE, 0, pl, "Too bad the %s isn't listening!\n", query_name (tmp));
…		…
1034	mflags = get_map_flags (m, &m, x, y, &x, &y);	1007	mflags = get_map_flags (m, &m, x, y, &x, &y);
1035	if (mflags & P_OUT_OF_MAP)	1008	if (mflags & P_OUT_OF_MAP)
1036	continue;	1009	continue;
1037		1010
1038	/* Check everything in the square for trapness */	1011	/* Check everything in the square for trapness */
1039	for (tmp = get_map_ob (m, x, y); tmp != NULL; tmp = tmp->above)	1012	for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1040	{	1013	{
1041		1014
1042	/* And now we'd better do an inventory traversal of each	1015	/* And now we'd better do an inventory traversal of each
1043	* of these objects' inventory	1016	* of these objects' inventory
1044	* We can narrow this down a bit - no reason to search through	1017	* We can narrow this down a bit - no reason to search through
…		…
1097	mflags = get_map_flags (m, &m, x, y, &x, &y);	1070	mflags = get_map_flags (m, &m, x, y, &x, &y);
1098	if (mflags & P_OUT_OF_MAP)	1071	if (mflags & P_OUT_OF_MAP)
1099	continue;	1072	continue;
1100		1073
1101	/* Check everything in the square for trapness */	1074	/* Check everything in the square for trapness */
1102	for (tmp = get_map_ob (m, x, y); tmp != NULL; tmp = tmp->above)	1075	for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1103	{	1076	{
1104	/* And now we'd better do an inventory traversal of each	1077	/* And now we'd better do an inventory traversal of each
1105	* of these objects inventory. Like above, only	1078	* of these objects inventory. Like above, only
1106	* do this for interesting objects.	1079	* do this for interesting objects.
1107	*/	1080	*/
…		…
1128	success += calc_skill_exp (op, tmp, skill);	1101	success += calc_skill_exp (op, tmp, skill);
1129	}	1102	}
1130	}	1103	}
1131	}	1104	}
1132	}	1105	}
		1106
1133	return success;	1107	return success;
1134	}	1108	}
1135
1136		1109
1137	/* pray() - when this skill is called from do_skill(), it allows	1110	/* pray() - when this skill is called from do_skill(), it allows
1138	* the player to regain lost grace points at a faster rate. -b.t.	1111	* the player to regain lost grace points at a faster rate. -b.t.
1139	* This always returns 0 - return value is used by calling function	1112	* This always returns 0 - return value is used by calling function
1140	* such that if it returns true, player gets exp in that skill. This	1113	* such that if it returns true, player gets exp in that skill. This
1141	* the effect here can be done on demand, we probably don't want to	1114	* the effect here can be done on demand, we probably don't want to
1142	* give infinite exp by returning true in any cases.	1115	* give infinite exp by returning true in any cases.
1143	*/	1116	*/
1144
1145	int	1117	int
1146	pray (object *pl, object *skill)	1118	pray (object *pl, object *skill)
1147	{	1119	{
1148	char buf[MAX_BUF];	1120	char buf[MAX_BUF];
1149	object *tmp;	1121	object *tmp;
…		…
1174	if (pl->stats.grace < pl->stats.maxgrace)	1146	if (pl->stats.grace < pl->stats.maxgrace)
1175	{	1147	{
1176	pl->stats.grace++;	1148	pl->stats.grace++;
1177	pl->last_grace = -1;	1149	pl->last_grace = -1;
1178	}	1150	}
		1151
1179	return 0;	1152	return 0;
1180	}	1153	}
1181		1154
1182	/* This skill allows the player to regain a few sp or hp for a	1155	/* This skill allows the player to regain a few sp or hp for a
1183	* brief period of concentration. No armour or weapons may be	1156	* brief period of concentration. No armour or weapons may be
1184	* wielded/applied for this to work. The amount of time needed	1157	* wielded/applied for this to work. The amount of time needed
1185	* to concentrate and the # of points regained is dependant on	1158	* to concentrate and the # of points regained is dependant on
1186	* the level of the user. - b.t. thomas@astro.psu.edu	1159	* the level of the user. - b.t. thomas@astro.psu.edu
1187	*/	1160	*/
1188
1189	void	1161	void
1190	meditate (object *pl, object *skill)	1162	meditate (object *pl, object *skill)
1191	{	1163	{
1192	object *tmp;	1164	object *tmp;
1193		1165
…		…
1201	return;	1173	return;
1202	}	1174	}
1203	else	1175	else
1204	{	1176	{
1205	for (tmp = pl->inv; tmp; tmp = tmp->below)	1177	for (tmp = pl->inv; tmp; tmp = tmp->below)
1206	if (((tmp->type == ARMOUR && skill->level < 12)	1178	if (((tmp->type == ARMOUR && skill->level < 12)
1207	|| (tmp->type == HELMET && skill->level < 10)	1179	|| (tmp->type == HELMET && skill->level < 10)
1208	|| (tmp->type == SHIELD && skill->level < 6)	1180	|| (tmp->type == SHIELD && skill->level < 6)
1209	|| (tmp->type == BOOTS && skill->level < 4) || (tmp->type == GLOVES && skill->level < 2)) && QUERY_FLAG (tmp, FLAG_APPLIED))	1181	|| (tmp->type == BOOTS && skill->level < 4)
		1182	|| (tmp->type == GLOVES && skill->level < 2))
		1183	&& QUERY_FLAG (tmp, FLAG_APPLIED))
1210	{	1184	{
1211	new_draw_info (NDI_UNIQUE, 0, pl, "You can't concentrate while wearing so much armour!\n");	1185	new_draw_info (NDI_UNIQUE, 0, pl, "You can't concentrate while wearing so much armour!\n");
1212	return;	1186	return;
1213	}	1187	}
1214	}	1188	}
…		…
1234	pl->last_heal = -1;	1208	pl->last_heal = -1;
1235	}	1209	}
1236	}	1210	}
1237		1211
1238	/* write_note() - this routine allows players to inscribe messages in	1212	/* write_note() - this routine allows players to inscribe messages in
1239	* ordinary 'books' (anything that is type BOOK). b.t.	1213	* ordinary inscribable 'books' (anything that is not a SPELL). b.t.
1240	*/	1214	*/
1241
1242	static int	1215	static int
1243	write_note (object *pl, object *item, const char *msg, object *skill)	1216	write_note (object *pl, object *item, const char *msg, object *skill)
1244	{	1217	{
		1218	if (strstr (msg, "\nendmsg"))
		1219	{
		1220	new_draw_info (NDI_UNIQUE, 0, pl, "Trying to cheat now are we?");
		1221	return 0;
		1222	}
		1223
		1224	int len = strlen (msg);
		1225
		1226	if (!is_utf8_string ((U8 *)msg, len))
		1227	{
		1228	new_draw_info_format (NDI_UNIQUE, 0, pl, "Your message is garbled (text must be UTF-8, client-bug)!");
		1229	return 0;
		1230	}
		1231
		1232	if (INVOKE_OBJECT (INSCRIBE_NOTE, item, ARG_PLAYER (pl->contr), ARG_STRING (msg), ARG_OBJECT (skill)))
		1233	return RESULT_INT (0);
		1234
1245	char buf[1024];	1235	char buf[1024];
1246	object *newBook = NULL;
1247		1236
1248	/* a pair of sanity checks */	1237	if (len < sizeof (buf) - 2)
1249	if (!item || item->type != BOOK)
1250	return 0;
1251
1252	if (!msg)
1253	{
1254	new_draw_info (NDI_UNIQUE, 0, pl, "No message to write!");
1255	new_draw_info_format (NDI_UNIQUE, 0, pl, "Usage: use_skill %s <message>", &skill->skill);
1256	return 0;
1257	}	1238	{
1258	if (strcasestr_local (msg, "endmsg"))	1239	snprintf (buf, sizeof (buf), "%s\n", msg);
1259	{
1260	new_draw_info (NDI_UNIQUE, 0, pl, "Trying to cheat now are we?");
1261	return 0;
1262	}
1263		1240
1264	if (INVOKE_OBJECT (INSCRIBE_NOTE, item, ARG_PLAYER (pl->contr), ARG_STRING (msg), ARG_OBJECT (skill)))	1241	object *newbook = arch_to_object (item->other_arch);
1265	return strlen (msg);	1242	item->decrease ();
1266
1267	buf[0] = 0;
1268	if (!book_overflow (item->msg, msg, sizeof (buf)))
1269	{ /* add msg string to book */
1270	if (item->msg)
1271	strcpy (buf, item->msg);
1272
1273	strcat (buf, msg);
1274	strcat (buf, "\n"); /* new msg needs a LF */
1275	if (item->nrof > 1)
1276	{
1277	newBook = get_object ();
1278	copy_object (item, newBook);
1279	decrease_ob (item);
1280	esrv_send_item (pl, item);
1281	newBook->nrof = 1;	1243	newbook->nrof = 1;
1282	newBook->msg = buf;	1244	newbook->msg = buf;
1283	newBook = insert_ob_in_ob (newBook, pl);	1245	newbook->flag [FLAG_IDENTIFIED] = true;
1284	esrv_send_item (pl, newBook);	1246
		1247	if (item->subtype == 1) // mailscrolls
1285	}	1248	{
1286	else	1249	newbook->name = item->name;
		1250	newbook->name_pl = item->name_pl;
1287	{	1251	}
1288	item->msg = buf;	1252
1289	/* This shouldn't be necessary - the object hasn't changed in any	1253	pl->insert (newbook);
1290	* visible way	1254
1291	*/	1255	pl->contr->play_sound (sound_find ("inscribe_success"));
1292	/* esrv_send_item(pl, item); */
1293	}
1294	new_draw_info_format (NDI_UNIQUE, 0, pl, "You write in the %s.", query_short_name (item));	1256	new_draw_info_format (NDI_UNIQUE, 0, pl, "You write in the %s.", &item->name);
1295	return strlen (msg);	1257	return strlen (msg);
1296	}	1258	}
1297	else	1259	else
1298	new_draw_info_format (NDI_UNIQUE, 0, pl, "Your message won't fit in the %s!", query_short_name (item));	1260	new_draw_info_format (NDI_UNIQUE, 0, pl, "Your message won't fit in the %s!", &item->name);
1299		1261
1300	return 0;	1262	return 0;
1301	}	1263	}
1302		1264
1303	/* write_scroll() - this routine allows players to inscribe spell scrolls	1265	/* write_scroll() - this routine allows players to inscribe spell scrolls
1304	* of spells which they know. Backfire effects are possible with the	1266	* of spells which they know. Backfire effects are possible with the
1305	* severity of the backlash correlated with the difficulty of the scroll	1267	* severity of the backlash correlated with the difficulty of the scroll
1306	* that is attempted. -b.t. thomas@astro.psu.edu	1268	* that is attempted. -b.t. thomas@astro.psu.edu
1307	*/	1269	*/
1308
1309	static int	1270	static int
1310	write_scroll (object *pl, object *scroll, object *skill)	1271	write_scroll (object *pl, object *scroll, object *skill)
1311	{	1272	{
1312	int success = 0, confused = 0;	1273	int success = 0, confused = 0;
1313	object *newscroll, *chosen_spell, *tmp;
1314
1315	/* this is a sanity check */
1316	if (scroll->type != SCROLL)
1317	{
1318	new_draw_info (NDI_UNIQUE, 0, pl, "A spell can only be inscribed into a scroll!");
1319	return 0;
1320	}
1321		1274
1322	/* Check if we are ready to attempt inscription */	1275	/* Check if we are ready to attempt inscription */
1323	chosen_spell = pl->contr->ranges[range_magic];	1276	object *chosen_spell = pl->contr->ranged_ob;
1324	if (!chosen_spell)	1277
		1278	if (!chosen_spell || chosen_spell->type != SPELL)
1325	{	1279	{
1326	new_draw_info (NDI_UNIQUE, 0, pl, "You need a spell readied in order to inscribe!");	1280	new_draw_info (NDI_UNIQUE, 0, pl, "You need a spell readied in order to inscribe!");
1327	return 0;	1281	return 0;
1328	}	1282	}
		1283
1329	if (SP_level_spellpoint_cost (pl, chosen_spell, SPELL_GRACE) > pl->stats.grace)	1284	if (SP_level_spellpoint_cost (pl, chosen_spell, SPELL_GRACE) > pl->stats.grace)
1330	{	1285	{
1331	new_draw_info_format (NDI_UNIQUE, 0, pl, "You don't have enough grace to write a scroll of %s.", &chosen_spell->name);	1286	new_draw_info_format (NDI_UNIQUE, 0, pl, "You don't have enough grace to write a scroll of %s.", &chosen_spell->name);
1332	return 0;	1287	return 0;
1333	}	1288	}
		1289
1334	if (SP_level_spellpoint_cost (pl, chosen_spell, SPELL_MANA) > pl->stats.sp)	1290	if (SP_level_spellpoint_cost (pl, chosen_spell, SPELL_MANA) > pl->stats.sp)
1335	{	1291	{
1336	new_draw_info_format (NDI_UNIQUE, 0, pl, "You don't have enough mana to write a scroll of %s.", &chosen_spell->name);	1292	new_draw_info_format (NDI_UNIQUE, 0, pl, "You don't have enough mana to write a scroll of %s.", &chosen_spell->name);
1337	return 0;
1338	}
1339
1340	/* if there is a spell already on the scroll then player could easily
1341	* accidently read it while trying to write the new one. give player
1342	* a 50% chance to overwrite spell at their own level
1343	*/
1344	if ((scroll->stats.sp || scroll->inv) && random_roll (0, scroll->level * 2, pl, PREFER_LOW) > skill->level)
1345	{
1346	new_draw_info_format (NDI_UNIQUE, 0, pl, "Oops! You accidently read it while trying to write on it.");
1347	manual_apply (pl, scroll, 0);
1348	return 0;	1293	return 0;
1349	}	1294	}
1350		1295
1351	/* ok, we are ready to try inscription */	1296	/* ok, we are ready to try inscription */
1352	if (QUERY_FLAG (pl, FLAG_CONFUSED))	1297	if (QUERY_FLAG (pl, FLAG_CONFUSED))
…		…
1356	pl->stats.grace -= SP_level_spellpoint_cost (pl, chosen_spell, SPELL_GRACE);	1301	pl->stats.grace -= SP_level_spellpoint_cost (pl, chosen_spell, SPELL_GRACE);
1357	pl->stats.sp -= SP_level_spellpoint_cost (pl, chosen_spell, SPELL_MANA);	1302	pl->stats.sp -= SP_level_spellpoint_cost (pl, chosen_spell, SPELL_MANA);
1358		1303
1359	if (random_roll (0, chosen_spell->level * 4 - 1, pl, PREFER_LOW) < skill->level)	1304	if (random_roll (0, chosen_spell->level * 4 - 1, pl, PREFER_LOW) < skill->level)
1360	{	1305	{
1361	if (scroll->nrof > 1)	1306	object *newscroll = arch_to_object (scroll->other_arch);
1362	{	1307	scroll->decrease ();
1363	newscroll = get_object ();
1364	copy_object (scroll, newscroll);
1365	decrease_ob (scroll);
1366	newscroll->nrof = 1;	1308	newscroll->nrof = 1;
1367	}	1309
1368	else	1310	pl->contr->play_sound (sound_find ("inscribe_success"));
1369	{
1370	newscroll = scroll;
1371	}
1372		1311
1373	if (!confused)	1312	if (!confused)
1374	{	1313	{
1375	newscroll->level = MAX (skill->level, chosen_spell->level);	1314	newscroll->level = MAX (skill->level, chosen_spell->level);
		1315	newscroll->flag [FLAG_IDENTIFIED] = true;
1376	new_draw_info (NDI_UNIQUE, 0, pl, "You succeed in writing a new scroll.");	1316	new_draw_info (NDI_UNIQUE, 0, pl, "You succeed in writing the spell.");
1377	}	1317	}
1378	else	1318	else
1379	{	1319	{
1380	chosen_spell = find_random_spell_in_ob (pl, NULL);	1320	chosen_spell = find_random_spell_in_ob (pl, NULL);
1381	if (!chosen_spell)	1321	if (!chosen_spell)
…		…
1383		1323
1384	newscroll->level = MAX (skill->level, chosen_spell->level);	1324	newscroll->level = MAX (skill->level, chosen_spell->level);
1385	new_draw_info (NDI_UNIQUE, 0, pl, "In your confused state, you write down some odd spell.");	1325	new_draw_info (NDI_UNIQUE, 0, pl, "In your confused state, you write down some odd spell.");
1386	}	1326	}
1387		1327
1388	if (newscroll->inv)	1328	object *tmp = chosen_spell->clone ();
1389	{
1390	object *ninv;
1391
1392	ninv = newscroll->inv;
1393	remove_ob (ninv);
1394	free_object (ninv);
1395	}
1396	tmp = get_object ();
1397	copy_object (chosen_spell, tmp);
1398	insert_ob_in_ob (tmp, newscroll);	1329	insert_ob_in_ob (tmp, newscroll);
1399		1330
1400	/* Same code as from treasure.c - so they can better merge.	1331	/* Same code as from treasure.C - so they can better merge.
1401	* if players want to sell them, so be it.	1332	* if players want to sell them, so be it.
1402	*/	1333	*/
1403	newscroll->value = newscroll->arch->clone.value * newscroll->inv->value * (newscroll->level + 50) / (newscroll->inv->level + 50);	1334	newscroll->value = newscroll->arch->value * newscroll->inv->value * (newscroll->level + 50) / (newscroll->inv->level + 50);
1404	newscroll->stats.exp = newscroll->value / 5;	1335	newscroll->stats.exp = newscroll->value / 5;
1405		1336
1406	/* wait until finished manipulating the scroll before inserting it */	1337	pl->insert (newscroll);
1407	if (newscroll == scroll)	1338
1408	{
1409	/* Remove to correctly merge with other items which may exist in inventory */
1410	remove_ob (newscroll);
1411	esrv_del_item (pl->contr, newscroll->count);
1412	}
1413	newscroll = insert_ob_in_ob (newscroll, pl);
1414	esrv_send_item (pl, newscroll);
1415	success = calc_skill_exp (pl, newscroll, skill);	1339	success = calc_skill_exp (pl, newscroll, skill);
1416	if (!confused)	1340	if (!confused)
1417	success *= 2;	1341	success *= 2;
		1342
1418	success = success * skill->level;	1343	success = success * skill->level;
1419	return success;	1344	return success;
1420
1421	}	1345	}
1422	else	1346	else
1423	{ /* Inscription has failed */	1347	{ /* Inscription has failed */
		1348	pl->contr->play_sound (sound_find ("inscribe_fail"));
1424		1349
1425	if (chosen_spell->level > skill->level || confused)	1350	if (chosen_spell->level > skill->level || confused)
1426	{ /*backfire! */	1351	{ /*backfire! */
1427	new_draw_info (NDI_UNIQUE, 0, pl, "Ouch! Your attempt to write a new scroll strains your mind!");	1352	new_draw_info (NDI_UNIQUE, 0, pl, "Ouch! Your attempt to write a new scroll strains your mind!");
		1353
1428	if (random_roll (0, 1, pl, PREFER_LOW) == 1)	1354	if (random_roll (0, 1, pl, PREFER_LOW) == 1)
1429	drain_specific_stat (pl, 4);	1355	pl->drain_specific_stat (4);
1430	else	1356	else
1431	{	1357	{
1432	confuse_player (pl, pl, 99);	1358	confuse_player (pl, pl, 99);
1433	return (-30 * chosen_spell->level);	1359	return -30 * chosen_spell->level;
1434	}	1360	}
1435	}	1361	}
1436	else if (random_roll (0, pl->stats.Int - 1, pl, PREFER_HIGH) < 15)	1362	else if (random_roll (0, pl->stats.Int - 1, pl, PREFER_HIGH) < 15)
1437	{	1363	{
1438	new_draw_info (NDI_UNIQUE, 0, pl, "Your attempt to write a new scroll rattles your mind!");	1364	new_draw_info (NDI_UNIQUE, 0, pl, "Your attempt to write a new scroll rattles your mind! H<Frankly spoken, you were too dumb and unlucky.>");
1439	confuse_player (pl, pl, 99);	1365	confuse_player (pl, pl, 99);
1440	}	1366	}
1441	else	1367	else
1442	new_draw_info (NDI_UNIQUE, 0, pl, "You fail to write a new scroll.");	1368	new_draw_info (NDI_UNIQUE, 0, pl, "You fail to write a new scroll. H<Try a lower-level spell, if possible at all.>");
1443	}	1369	}
		1370
1444	return 0;	1371	return 0;
1445	}	1372	}
1446		1373
1447	/* write_on_item() - wrapper for write_note and write_scroll */	1374	/* write_on_item() - wrapper for write_note and write_scroll */
1448	int	1375	int
1449	write_on_item (object *pl, const char *params, object *skill)	1376	write_on_item (object *pl, const char *params, object *skill)
1450	{	1377	{
1451	object *item;
1452	const char *string = params;
1453	int msgtype;
1454	archetype *skat;	1378	archetype *skat;
1455		1379
1456	if (pl->type != PLAYER)	1380	if (pl->type != PLAYER)
1457	return 0;	1381	return 0;
1458		1382
1459	if (!params)	1383	if (!params)
1460	{
1461	params = "";	1384	params = "";
1462	string = params;	1385
1463	}
1464	skat = get_archetype_by_type_subtype (SKILL, SK_LITERACY);	1386	skat = get_archetype_by_type_subtype (SKILL, SK_LITERACY);
1465		1387
1466	/* Need to be able to read before we can write! */	1388	/* Need to be able to read before we can write! */
1467	if (!find_skill_by_name (pl, skat->clone.skill))	1389	if (!find_skill_by_name (pl, skat->skill))
1468	{	1390	{
1469	new_draw_info (NDI_UNIQUE, 0, pl, "You must learn to read before you can write!");	1391	new_draw_info (NDI_UNIQUE, 0, pl, "You must learn to read before you can write! H<You lack the literacy skill.>");
1470	return 0;	1392	return 0;
1471	}	1393	}
1472		1394
1473	/* if there is a message then it goes in a book and no message means	1395	object *item = find_marked_object (pl);
1474	* write active spell into the scroll
1475	*/
1476	msgtype = (string[0] != '\0') ? BOOK : SCROLL;
1477		1396
1478	/* find an item of correct type to write on */	1397	/* find an item of correct type to write on */
1479	if (!(item = find_marked_object (pl)))	1398	if (!item)
		1399	{
		1400	new_draw_info (NDI_UNIQUE, 0, pl, "You don't have any marked item to write on. H<Use the mark command or the popup menu to make an item.>");
		1401	return 0;
1480	{	1402	}
1481	new_draw_info (NDI_UNIQUE, 0, pl, "You don't have any marked item to write on.");	1403
		1404	if (item->type != INSCRIBABLE)
		1405	{
		1406	new_draw_info_format (NDI_UNIQUE, 0, pl, "You cannot inscribe this! H<You can only inscribe empty scrolls and books.>");
1482	return 0;	1407	return 0;
1483	}	1408	}
1484		1409
1485	if (QUERY_FLAG (item, FLAG_UNPAID))	1410	if (QUERY_FLAG (item, FLAG_UNPAID))
1486	{	1411	{
1487	new_draw_info (NDI_UNIQUE, 0, pl, "You had better pay for that before you write on it.");	1412	new_draw_info (NDI_UNIQUE, 0, pl, "You had better pay for that before you write on it.");
1488	return 0;	1413	return 0;
1489	}	1414	}
1490	if (msgtype != item->type)	1415
		1416	if (item->other_arch->type == SCROLL)
1491	{	1417	{
1492	new_draw_info_format (NDI_UNIQUE, 0, pl, "You have no %s to write on", msgtype == BOOK ? "book" : "scroll");	1418	if (*params)
		1419	{
		1420	// check readied scroll
		1421	new_draw_info_format (NDI_UNIQUE, 0, pl,
		1422	"When inscribing spells you need to ready a spell and do not specify a string argument.\n"
		1423	"Usage: cast [spell name]; use_skill %s", &skill->skill);
1493	return 0;	1424	return 0;
1494	}	1425	}
1495		1426
1496	if (msgtype == SCROLL)
1497	{
1498	return write_scroll (pl, item, skill);	1427	return write_scroll (pl, item, skill);
1499	}	1428	}
1500	else if (msgtype == BOOK)	1429	else
1501	{	1430	{
		1431	if (!*params)
		1432	{
		1433	new_draw_info_format (NDI_UNIQUE, 0, pl,
		1434	"When inscribing books you need to specify the words you want to inscribe as command argument.\n"
		1435	"Usage: use_skill %s <message>", &skill->skill);
		1436	return 0;
		1437	}
		1438
1502	return write_note (pl, item, string, skill);	1439	return write_note (pl, item, params, skill);
1503	}	1440	}
		1441
1504	return 0;	1442	return 0;
1505	}	1443	}
1506
1507
1508		1444
1509	/* find_throw_ob() - if we request an object, then	1445	/* find_throw_ob() - if we request an object, then
1510	* we search for it in the inventory of the owner (you've	1446	* we search for it in the inventory of the owner (you've
1511	* got to be carrying something in order to throw it!).	1447	* got to be carrying something in order to throw it!).
1512	* If we didnt request an object, then the top object in inventory	1448	* If we didnt request an object, then the top object in inventory
1513	* (that is "throwable", ie no throwing your skills away!)	1449	* (that is "throwable", ie no throwing your skills away!)
1514	* is the object of choice. Also check to see if object is	1450	* is the object of choice. Also check to see if object is
1515	* 'throwable' (ie not applied cursed obj, worn, etc).	1451	* 'throwable' (ie not applied cursed obj, worn, etc).
1516	*/	1452	*/
1517
1518	static object *	1453	static object *
1519	find_throw_ob (object *op, const char *request)	1454	find_throw_ob (object *op, const char *request)
1520	{	1455	{
1521	object *tmp;	1456	object *tmp;
1522		1457
…		…
1592	return tmp;	1527	return tmp;
1593	}	1528	}
1594		1529
1595	/* make_throw_ob() We construct the 'carrier' object in	1530	/* make_throw_ob() We construct the 'carrier' object in
1596	* which we will insert the object that is being thrown.	1531	* which we will insert the object that is being thrown.
1597	* This combination becomes the 'thrown object'. -b.t.	1532	* This combination becomes the 'thrown object'. -b.t.
1598	*/	1533	*/
1599
1600	static object *	1534	static object *
1601	make_throw_ob (object *orig)	1535	make_throw_ob (object *orig)
1602	{	1536	{
1603	object *toss_item;
1604
1605	if (!orig)	1537	if (!orig)
1606	return NULL;	1538	return 0;
1607		1539
1608	toss_item = get_object ();
1609	if (QUERY_FLAG (orig, FLAG_APPLIED))	1540	if (QUERY_FLAG (orig, FLAG_APPLIED))
1610	{	1541	{
1611	LOG (llevError, "BUG: make_throw_ob(): ob is applied\n");	1542	LOG (llevError, "BUG: make_throw_ob(): ob is applied\n");
1612	/* insufficient workaround, but better than nothing */	1543	/* insufficient workaround, but better than nothing */
1613	CLEAR_FLAG (orig, FLAG_APPLIED);	1544	CLEAR_FLAG (orig, FLAG_APPLIED);
1614	}	1545	}
1615	copy_object (orig, toss_item);	1546
		1547	object *toss_item = orig->clone ();
		1548
1616	toss_item->type = THROWN_OBJ;	1549	toss_item->type = THROWN_OBJ;
1617	CLEAR_FLAG (toss_item, FLAG_CHANGING);	1550	CLEAR_FLAG (toss_item, FLAG_CHANGING);
1618	toss_item->stats.dam = 0; /* default damage */	1551	toss_item->stats.dam = 0; /* default damage */
1619	insert_ob_in_ob (orig, toss_item);	1552	toss_item->insert (orig);
		1553
1620	return toss_item;	1554	return toss_item;
1621	}	1555	}
1622
1623		1556
1624	/* do_throw() - op throws any object toss_item. This code	1557	/* do_throw() - op throws any object toss_item. This code
1625	* was borrowed from fire_bow.	1558	* was borrowed from fire_bow.
1626	* Returns 1 if skill was successfully used, 0 if not	1559	* Returns 1 if skill was successfully used, 0 if not
1627	*/	1560	*/
1628
1629	static int	1561	static int
1630	do_throw (object *op, object *part, object *toss_item, int dir, object *skill)	1562	do_throw (object *op, object *part, object *toss_item, int dir, object *skill)
1631	{	1563	{
1632	object *throw_ob = toss_item, *left = NULL;	1564	object *throw_ob = toss_item, *left = NULL;
1633	int eff_str = 0, maxc, str = op->stats.Str, dam = 0;	1565	int eff_str = 0, maxc, str = op->stats.Str, dam = 0;
…		…
1698	*/	1630	*/
1699	mflags = get_map_flags (part->map, &m, part->x + freearr_x[dir], part->y + freearr_y[dir], &sx, &sy);	1631	mflags = get_map_flags (part->map, &m, part->x + freearr_x[dir], part->y + freearr_y[dir], &sx, &sy);
1700		1632
1701	if (!dir || (eff_str <= 1) || (mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, sx, sy) & MOVE_FLY_LOW))	1633	if (!dir || (eff_str <= 1) || (mflags & P_OUT_OF_MAP) || (GET_MAP_MOVE_BLOCK (m, sx, sy) & MOVE_FLY_LOW))
1702	{	1634	{
1703
1704	/* bounces off 'wall', and drops to feet */	1635	/* bounces off 'wall', and drops to feet */
1705	remove_ob (throw_ob);	1636	throw_ob->insert_at (part, op);
1706	throw_ob->x = part->x;	1637
1707	throw_ob->y = part->y;
1708	insert_ob_in_map (throw_ob, part->map, op, 0);
1709	if (op->type == PLAYER)	1638	if (op->type == PLAYER)
1710	{	1639	{
1711	if (eff_str <= 1)	1640	if (eff_str <= 1)
1712	{
1713	new_draw_info_format (NDI_UNIQUE, 0, op, "Your load is so heavy you drop %s to the ground.", query_name (throw_ob));	1641	new_draw_info_format (NDI_UNIQUE, 0, op, "Your load is so heavy you drop %s to the ground.", query_name (throw_ob));
1714	}
1715	else if (!dir)	1642	else if (!dir)
1716	{
1717	new_draw_info_format (NDI_UNIQUE, 0, op, "You throw %s at the ground.", query_name (throw_ob));	1643	new_draw_info_format (NDI_UNIQUE, 0, op, "You throw %s at the ground.", query_name (throw_ob));
1718	}
1719	else	1644	else
1720	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");	1645	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
1721	}	1646	}
		1647
1722	return 0;	1648	return 0;
1723	} /* if object can't be thrown */	1649	} /* if object can't be thrown */
1724		1650
1725	left = throw_ob; /* these are throwing objects left to the player */	1651	left = throw_ob; /* these are throwing objects left to the player */
1726		1652
1727	/* sometimes get_split_ob can't split an object (because op->nrof==0?)	1653	/* sometimes get_split_ob can't split an object (because op->nrof==0?)
1728	* and returns NULL. We must use 'left' then	1654	* and returns NULL. We must use 'left' then
1729	*/	1655	*/
1730		1656	if (!(throw_ob = throw_ob->split ()))
1731	if ((throw_ob = get_split_ob (throw_ob, 1)) == NULL)
1732	{	1657	{
1733	throw_ob = left;	1658	throw_ob = left;
1734	remove_ob (left);	1659	left->remove ();
1735	if (op->type == PLAYER)
1736	esrv_del_item (op->contr, left->count);
1737	}
1738	else if (op->type == PLAYER)
1739	{
1740	if (left->destroyed ())
1741	esrv_del_item (op->contr, left->count);
1742	else
1743	esrv_update_item (UPD_NROF, op, left);
1744	}	1660	}
1745		1661
1746	/* special case: throwing powdery substances like dust, dirt */	1662	/* special case: throwing powdery substances like dust, dirt */
1747	if (throw_ob->type == POTION && throw_ob->subtype == POT_DUST)	1663	if (throw_ob->type == POTION && throw_ob->subtype == POT_DUST)
1748	{	1664	{
…		…
1763	{	1679	{
1764	insert_ob_in_ob (throw_ob, op);	1680	insert_ob_in_ob (throw_ob, op);
1765	return 0;	1681	return 0;
1766	}	1682	}
1767		1683
1768	set_owner (throw_ob, op);	1684	throw_ob->set_owner (op);
1769	/* At some point in the attack code, the actual real object (op->inv)	1685	/* At some point in the attack code, the actual real object (op->inv)
1770	* becomes the hitter. As such, we need to make sure that has a proper	1686	* becomes the hitter. As such, we need to make sure that has a proper
1771	* owner value so exp goes to the right place.	1687	* owner value so exp goes to the right place.
1772	*/	1688	*/
1773	set_owner (throw_ob->inv, op);	1689	throw_ob->inv->set_owner (op);
1774	throw_ob->direction = dir;	1690	throw_ob->direction = dir;
1775	throw_ob->x = part->x;
1776	throw_ob->y = part->y;
1777		1691
1778	/* the damage bonus from the force of the throw */	1692	/* the damage bonus from the force of the throw */
1779	dam = (int) (str_factor * dam_bonus[eff_str]);	1693	dam = int (str_factor * dam_bonus[eff_str]);
1780		1694
1781	/* Now, lets adjust the properties of the thrown_ob. */	1695	/* Now, lets adjust the properties of the thrown_ob. */
1782		1696
1783	/* how far to fly */	1697	/* how far to fly */
1784	throw_ob->last_sp = (eff_str * 3) / 5;	1698	throw_ob->last_sp = (eff_str * 3) / 5;
1785		1699
1786	/* speed */	1700	/* speed */
1787	throw_ob->speed = (speed_bonus[eff_str] + 1.0) / 1.5;	1701	throw_ob->set_speed (min (1.0, speed_bonus[eff_str] + 1.0) / 1.5); /* no faster than an arrow! */
1788	throw_ob->speed = MIN (1.0, throw_ob->speed); /* no faster than an arrow! */
1789		1702
1790	/* item damage. Eff_str and item weight influence damage done */	1703	/* item damage. Eff_str and item weight influence damage done */
1791	weight_f = (throw_ob->weight / 2000) > MAX_STAT ? MAX_STAT : (throw_ob->weight / 2000);	1704	weight_f = (throw_ob->weight / 2000) > MAX_STAT ? MAX_STAT : (throw_ob->weight / 2000);
1792	throw_ob->stats.dam += (dam / 3) + dam_bonus[weight_f] + (throw_ob->weight / 15000) - 2;	1705	throw_ob->stats.dam += (dam / 3) + dam_bonus[weight_f] + (throw_ob->weight / 15000) - 2;
1793		1706
1794	/* chance of breaking. Proportional to force used and weight of item */	1707	/* chance of breaking. Proportional to force used and weight of item */
1795	throw_ob->stats.food = (dam / 2) + (throw_ob->weight / 60000);	1708	throw_ob->stats.food = (dam / 2) + (throw_ob->weight / 60000);
1796		1709
1797	/* replace 25 with a call to clone.arch wc? messes up w/ NPC */	1710	/* replace 25 with a call to clone.arch wc? messes up w/ NPC */
1798	throw_ob->stats.wc = 25 - dex_bonus[op->stats.Dex] - thaco_bonus[eff_str] - skill->level;	1711	throw_ob->stats.wc = 25 - dex_bonus[op->stats.Dex] - thaco_bonus[eff_str] - skill->level;
1799
1800		1712
1801	/* the properties of objects which are meant to be thrown (ie dart,	1713	/* the properties of objects which are meant to be thrown (ie dart,
1802	* throwing knife, etc) will differ from ordinary items. Lets tailor	1714	* throwing knife, etc) will differ from ordinary items. Lets tailor
1803	* this stuff in here.	1715	* this stuff in here.
1804	*/	1716	*/
…		…
1812	if (GET_ANIM_ID (throw_ob) && NUM_ANIMATIONS (throw_ob))	1724	if (GET_ANIM_ID (throw_ob) && NUM_ANIMATIONS (throw_ob))
1813	SET_ANIMATION (throw_ob, dir);	1725	SET_ANIMATION (throw_ob, dir);
1814	}	1726	}
1815	else	1727	else
1816	{	1728	{
		1729	uint16 mat = throw_ob->materials;
		1730
1817	/* some materials will adjust properties.. */	1731	/* some materials will adjust properties.. */
1818	if (throw_ob->material & M_LEATHER)	1732	if (mat & M_LEATHER)
1819	{	1733	{
1820	throw_ob->stats.dam -= 1;	1734	throw_ob->stats.dam -= 1;
1821	throw_ob->stats.food -= 10;	1735	throw_ob->stats.food -= 10;
1822	}	1736	}
		1737
1823	if (throw_ob->material & M_GLASS)	1738	if (mat & M_GLASS)
1824	throw_ob->stats.food += 60;	1739	throw_ob->stats.food += 60;
1825		1740
1826	if (throw_ob->material & M_ORGANIC)	1741	if (mat & M_ORGANIC)
1827	{	1742	{
1828	throw_ob->stats.dam -= 3;	1743	throw_ob->stats.dam -= 3;
1829	throw_ob->stats.food += 55;	1744	throw_ob->stats.food += 55;
1830	}	1745	}
1831	if (throw_ob->material & M_PAPER || throw_ob->material & M_CLOTH)	1746
		1747	if (mat & M_PAPER || mat & M_CLOTH)
1832	{	1748	{
1833	throw_ob->stats.dam -= 5;	1749	throw_ob->stats.dam -= 5;
1834	throw_ob->speed *= 0.8;	1750	throw_ob->speed *= 0.8;
1835	throw_ob->stats.wc += 3;	1751	throw_ob->stats.wc += 3;
1836	throw_ob->stats.food -= 30;	1752	throw_ob->stats.food -= 30;
1837	}	1753	}
		1754
1838	/* light obj have more wind resistance, fly slower */	1755	/* light obj have more wind resistance, fly slower */
1839	if (throw_ob->weight > 500)	1756	if (throw_ob->weight > 500)
1840	throw_ob->speed *= 0.8;	1757	throw_ob->speed *= 0.8;
		1758
1841	if (throw_ob->weight > 50)	1759	if (throw_ob->weight > 50)
1842	throw_ob->speed *= 0.5;	1760	throw_ob->speed *= 0.5;
1843
1844	} /* else tailor thrown object */	1761	} /* else tailor thrown object */
1845		1762
1846	/* some limits, and safeties (needed?) */	1763	/* some limits, and safeties (needed?) */
1847	if (throw_ob->stats.dam < 0)	1764	if (throw_ob->stats.dam < 0)
1848	throw_ob->stats.dam = 0;	1765	throw_ob->stats.dam = 0;
…		…
1868	* In short summary, a throw can take anywhere between speed 5 and	1785	* In short summary, a throw can take anywhere between speed 5 and
1869	* speed 0.5	1786	* speed 0.5
1870	*/	1787	*/
1871	op->speed_left -= 50 / pause_f;	1788	op->speed_left -= 50 / pause_f;
1872		1789
1873	update_ob_speed (throw_ob);
1874	throw_ob->speed_left = 0;	1790	throw_ob->speed_left = 0;
1875	throw_ob->map = part->map;	1791	throw_ob->map = part->map;
1876		1792
1877	throw_ob->move_type = MOVE_FLY_LOW;	1793	throw_ob->move_type = MOVE_FLY_LOW;
1878	throw_ob->move_on = MOVE_FLY_LOW | MOVE_WALK;	1794	throw_ob->move_on = MOVE_FLY_LOW | MOVE_WALK;
…		…
1888	LOG (llevDebug, " pause_f=%d \n", pause_f);	1804	LOG (llevDebug, " pause_f=%d \n", pause_f);
1889	LOG (llevDebug, " %s stats: wc=%d dam=%d dist=%d spd=%f break=%d\n",	1805	LOG (llevDebug, " %s stats: wc=%d dam=%d dist=%d spd=%f break=%d\n",
1890	throw_ob->name, throw_ob->stats.wc, throw_ob->stats.dam, throw_ob->last_sp, throw_ob->speed, throw_ob->stats.food);	1806	throw_ob->name, throw_ob->stats.wc, throw_ob->stats.dam, throw_ob->last_sp, throw_ob->speed, throw_ob->stats.food);
1891	LOG (llevDebug, "inserting tossitem (%d) into map\n", throw_ob->count);	1807	LOG (llevDebug, "inserting tossitem (%d) into map\n", throw_ob->count);
1892	#endif	1808	#endif
1893	insert_ob_in_map (throw_ob, part->map, op, 0);	1809
		1810	throw_ob->insert_at (part, op);
1894		1811
1895	if (!throw_ob->destroyed ())	1812	if (!throw_ob->destroyed ())
1896	move_arrow (throw_ob);	1813	move_arrow (throw_ob);
1897		1814
1898	return 1;	1815	return 1;

Diff Legend

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