ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/alchemy.C

Comparing deliantra/server/server/alchemy.C (file contents):
Revision 1.35 by elmex, Sun Jan 4 16:30:39 2009 UTC vs.
Revision 1.59 by root, Tue Jan 3 11:25:35 2012 UTC

1	/*	1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.	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 (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992 Frank Tore Johansen
7	*	7	*
8	* Deliantra is free software: you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* it under the terms of the GNU General Public License as published by	9	* the terms of the Affero GNU General Public License as published by the
10	* the Free Software Foundation, either version 3 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
11	* (at your option) any later version.	11	* option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the Affero GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.	19	* and the GNU General Public License along with this program. If not, see
		20	* <http://www.gnu.org/licenses/>.
20	*	21	*
21	* The authors can be reached via e-mail to <support@deliantra.net>	22	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	23	*/
23		24
24	/* March 96 - Laid down original code. -b.t. thomas@astro.psu.edu */	25	/* March 96 - Laid down original code. -b.t. thomas@astro.psu.edu */
…		…
55	"rattles",	56	"rattles",
56	"makes chugging sounds",	57	"makes chugging sounds",
57	"smokes heavily for a while"	58	"smokes heavily for a while"
58	};	59	};
59		60
60
61	static int is_defined_recipe (const recipe *rp, const object *cauldron, object *caster);	61	static int is_defined_recipe (const recipe *rp, const object *cauldron, object *caster);
62	static recipe *find_recipe (recipelist * fl, int formula, object *ingredients);	62	static recipe *find_recipe (recipelist * fl, int formula, object *ingredients);
63		63
64
65	/** Returns a random selection from cauldron_effect[] */	64	/** Returns a random selection from cauldron_effect[] */
66	static const char *	65	static const char *
67	cauldron_sound (void)	66	cauldron_sound ()
68	{	67	{
69	int size = sizeof (cauldron_effect) / sizeof (char *);	68	return cauldron_effect [rndm (array_length (cauldron_effect))];
70
71	return cauldron_effect[rndm (0, size - 1)];
72	}	69	}
73		70
74	/**	71	/**
		72	* Recipe value of the entire contents of a container.
		73	* This appears to just generate a hash value, which I guess for now works
		74	* ok, but the possibility of duplicate hashes is certainly possible - msw
		75	*/
		76	static int
		77	content_recipe_value (object *op)
		78	{
		79	object *tmp = op->inv;
		80	int formula = 0;
		81
		82	while (tmp)
		83	{
		84	const char *name = tmp->title
		85	? (const char *)format ("%s %s", &tmp->name, &tmp->title)
		86	: tmp->name;
		87
		88	int tval = strtoint (name) * tmp->number_of ();
		89	#ifdef ALCHEMY_DEBUG
		90	LOG (llevDebug, "Got ingredient %d %s(%d)\n", tmp->nrof ? tmp->nrof : 1, name, tval);
		91	#endif
		92	formula += tval;
		93	tmp = tmp->below;
		94	}
		95	#ifdef ALCHEMY_DEBUG
		96	LOG (llevDebug, " Formula value=%d\n", formula);
		97	#endif
		98
		99	return formula;
		100	}
		101
		102	/**
		103	* Returns total number of items in op
		104	*/
		105	static int
		106	numb_ob_inside (object *op)
		107	{
		108	object *tmp = op->inv;
		109	int number = 0, o_number = 0;
		110
		111	while (tmp)
		112	{
		113	if (tmp->nrof)
		114	number += tmp->nrof;
		115	else
		116	number++;
		117	o_number++;
		118	tmp = tmp->below;
		119	}
		120	#ifdef ALCHEMY_DEBUG
		121	LOG (llevDebug, "numb_ob_inside(%s): found %d ingredients\n", &op->name, o_number);
		122	#endif
		123	return o_number;
		124	}
		125
		126	/**
		127	* Looks through the ingredient list. If we find a
		128	* suitable object in it - we will use that to make the requested artifact.
		129	* Otherwise the code returns a 'generic' item if create_item is set. -b.t.
		130	*
		131	* @param rp_arch_index pointer to return value; set to arch index for recipe;
		132	* set to zero if not using a transmution formula
		133	*/
		134	static object *
		135	find_transmution_ob (object *first_ingred, recipe *rp, size_t *rp_arch_index, int create_item)
		136	{
		137	object *prod_item = 0;
		138	bool found = false;
		139	*rp_arch_index = 0;
		140
		141	if (rp->transmute) /* look for matching ingredient/prod archs */
		142	for (object *item = first_ingred; item; item = item->below)
		143	{
		144	for (int i = 0; i < rp->arch_names; i++)
		145	//TODO: should be a shstr comparison
		146	if (!strcmp(&item->arch->archname,rp->arch_name[i]))
		147	{
		148	*rp_arch_index = i;
		149	prod_item = item;
		150	break;
		151	}
		152
		153	if (prod_item)
		154	break;
		155	}
		156
		157	/* failed, create a fresh object. Note no nrof>1 because that would
		158	* allow players to create massive amounts of artifacts easily */
		159	if (create_item && (!prod_item || prod_item->nrof > 1))
		160	{
		161	#ifdef ALCHEMY_DEBUG
		162	LOG (llevDebug, "creating a new item.\n");
		163	if (prod_item != NULL)
		164	{
		165	LOG (llevDebug, " had item: arch %s(nrof:%d)\n",
		166	&prod_item->arch->archname, prod_item->nrof);
		167	}
		168	#endif
		169	if (!prod_item)
		170	*rp_arch_index = rndm (rp->arch_names);
		171	prod_item = archetype::get (rp->arch_name[*rp_arch_index]);
		172	}
		173
		174	#ifdef ALCHEMY_DEBUG
		175	LOG (llevDebug, "recipe calls for%stransmution.\n", rp->transmute ? " " : " no ");
		176	if (prod_item != NULL)
		177	{
		178	LOG (llevDebug, " find_transmutable_ob(): returns arch %s(sp:%d)\n",
		179	&prod_item->arch->archname, prod_item->stats.sp);
		180	}
		181	#endif
		182
		183	return prod_item;
		184	}
		185
		186	/**
		187	* Using a list of items and a recipe to make an artifact.
		188	*
		189	* @param cauldron the cauldron (including the ingredients) used to make the item
		190	*
		191	* @param rp the recipe to make the artifact from
		192	*
		193	* @return the newly created object, NULL if something failed
		194	*/
		195	static object *
		196	make_item_from_recipe (object *cauldron, recipe *rp)
		197	{
		198	artifact *art = NULL;
		199	object *item = NULL;
		200	size_t rp_arch_index;
		201
		202	if (rp == NULL)
		203	return (object *) NULL;
		204
		205	/* Find the appropriate object to transform... */
		206	if ((item = find_transmution_ob (cauldron->inv, rp, &rp_arch_index, 1)) == NULL)
		207	{
		208	LOG (llevDebug, "make_alchemy_item(): failed to create alchemical object.\n");
		209	return (object *) NULL;
		210	}
		211
		212	/* Find the appropriate artifact template... */
		213	if (rp->title != shstr_NONE)
		214	{
		215	if ((art = locate_recipe_artifact (rp, rp_arch_index)) == NULL)
		216	{
		217	LOG (llevError, "make_alchemy_item(): failed to locate recipe artifact.\n");
		218	LOG (llevDebug, " --requested recipe: %s of %s.\n", rp->arch_name[0], &rp->title);
		219	return (object *) NULL;
		220	}
		221
		222	transmute_materialname (item, art->item);
		223	give_artifact_abilities (item, art->item);
		224	}
		225
		226	if (cauldron->flag [FLAG_CURSED])
		227	item->set_flag (FLAG_CURSED);
		228	if (cauldron->flag [FLAG_DAMNED])
		229	item->set_flag (FLAG_DAMNED);
		230
		231	return item;
		232	}
		233
		234	/*
		235	* All but object "save_item" are elimentated from
		236	* the container list. Note we have to becareful to remove the inventories
		237	* of objects in the cauldron inventory (ex icecube has stuff in it).
		238	*/
		239	static void
		240	remove_contents (object *first_ob, object *save_item)
		241	{
		242	// this cries for a cleaner rewrite, removing save_item first possibly
		243	object *next, *tmp = first_ob;
		244
		245	while (tmp)
		246	{
		247	next = tmp->below;
		248
		249	if (tmp == save_item)
		250	{
		251	if (!(tmp = next))
		252	break;
		253	else
		254	next = next->below;
		255	}
		256
		257	if (tmp->inv)
		258	remove_contents (tmp->inv, NULL);
		259
		260	tmp->destroy ();
		261	tmp = next;
		262	}
		263	}
		264
		265	/**
		266	* We adjust the nrof, exp and level of the final product, based
		267	* on the item's default parameters, and the relevant caster skill level.
		268	*/
		269	static void
		270	adjust_product (object *item, int lvl, int yield)
		271	{
		272	int nrof = 1;
		273
		274	if (!yield)
		275	yield = 1;
		276
		277	if (lvl <= 0)
		278	lvl = 1; /* lets avoid div by zero! */
		279
		280	if (item->nrof)
		281	{
		282	nrof = (int) ((1.0 - 1.0 / (lvl / 10.0 + 1.0)) * (rndm (0, yield - 1) + rndm (0, yield - 1) + rndm (0, yield - 1)) + 1);
		283
		284	if (nrof > yield)
		285	nrof = yield;
		286
		287	item->nrof = nrof;
		288	}
		289	}
		290
		291	/**
		292	* Essentially a wrapper for make_item_from_recipe() and
		293	* insert_ob_in_ob. If the caster has some alchemy skill, then they might
		294	* gain some exp from (successfull) fabrication of the product.
		295	* If nbatches==-1, don't give exp for this creation (random generation/
		296	* failed recipe)
		297	*/
		298	static object *
		299	attempt_recipe (object *caster, object *cauldron, int ability, recipe *rp, int nbatches)
		300	{
		301
		302	object *item = NULL, *skop;
		303
		304	/* this should be passed to this fctn, not effiecent cpu use this way */
		305	int batches = abs (nbatches);
		306
		307	/* is the cauldron the right type? */
		308	if (rp->cauldron && rp->cauldron != cauldron->arch->archname)
		309	return 0;
		310
		311	skop = find_skill_by_name (caster, rp->skill);
		312	/* does the caster have the skill? */
		313	if (!skop)
		314	return 0;
		315
		316	/* code required for this recipe, search the caster */
		317	if (rp->keycode)
		318	{
		319	object *tmp;
		320
		321	for (tmp = caster->inv; tmp; tmp = tmp->below)
		322	{
		323	if (tmp->type == FORCE && tmp->slaying && rp->keycode == tmp->slaying)
		324	break;
		325	}
		326
		327	if (!tmp)
		328	{ /* failure--no code found */
		329	new_draw_info (NDI_UNIQUE, 0, caster, "You know the ingredients, but not the technique. Go learn how to do this recipe.");
		330	return 0;
		331	}
		332	}
		333
		334	#ifdef EXTREME_ALCHEMY_DEBUG
		335	LOG (llevDebug, "attempt_recipe(): got %d nbatches\n", nbatches);
		336	LOG (llevDebug, "attempt_recipe(): using recipe %s\n", *rp->title ? &rp->title : "unknown");
		337	#endif
		338
		339	if ((item = make_item_from_recipe (cauldron, rp)) != NULL)
		340	{
		341	remove_contents (cauldron->inv, item);
		342	/* Recalc carrying of the cauldron, in case recipe did not conserve mass */
		343	cauldron->update_weight ();
		344	/* adj lvl, nrof on caster level */
		345	adjust_product (item, ability, rp->yield ? rp->yield * batches : batches);
		346
		347	if (!item->env && (item = insert_ob_in_ob (item, cauldron)) == NULL)
		348	{
		349	new_draw_info (NDI_UNIQUE, 0, caster, "Nothing happened.");
		350	/* new_draw_info_format(NDI_UNIQUE, 0,caster,
		351	"Your spell causes the %s to explode!",&cauldron->name); */
		352	/* kaboom_cauldron(); */
		353	}
		354	else
		355	new_draw_info_format (NDI_UNIQUE, 0, caster, "The %s %s.", &cauldron->name, cauldron_sound ());
		356	}
		357
		358	return item;
		359	}
		360
		361	/**
		362	* Ouch. We didnt get the formula we wanted.
		363	* This fctn simulates the backfire effects--worse effects as the level
		364	* increases. If SPELL_FAILURE_EFFECTS is defined some really evil things
		365	* can happen to the would be alchemist. This table probably needs some
		366	* adjustment for playbalance. -b.t.
		367	*/
		368	static void
		369	alchemy_failure_effect (object *op, object *cauldron, recipe *rp, int danger)
		370	{
		371	int level = 0;
		372
		373	if (!op || !cauldron)
		374	return;
		375
		376	if (danger > 1)
		377	level = random_roll (1, danger, op, PREFER_LOW);
		378
		379	#ifdef ALCHEMY_DEBUG
		380	LOG (llevDebug, "Alchemy_failure_effect(): using level=%d\n", level);
		381	#endif
		382
		383	/* possible outcomes based on level */
		384	if (level < 25)
		385	{ /* INGREDIENTS USED/SLAGGED */
		386	object *item = NULL;
		387
		388	if (rndm (0, 2))
		389	{ /* slag created */
		390	object *tmp = cauldron->inv;
		391	int weight = 0;
		392
		393	tmp = archetype::get (shstr_rock);
		394	tmp->weight = weight;
		395	tmp->value = 0;
		396	tmp->material = name_to_material (shstr_stone);
		397	tmp->name = shstr_slag;
		398	tmp->name_pl = shstr_slags;
		399	item = insert_ob_in_ob (tmp, cauldron);
		400	tmp->clr_flag (FLAG_CAN_ROLL);
		401	tmp->set_flag (FLAG_NO_DROP);
		402	tmp->move_block = 0;
		403	}
		404
		405	remove_contents (cauldron->inv, item);
		406	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s %s.", &cauldron->name, cauldron_sound ());
		407	return;
		408	}
		409	else if (level < 40)
		410	{ /* MAKE TAINTED ITEM */
		411	object *tmp = NULL;
		412
		413	if (!rp)
		414	if ((rp = get_random_recipe ((recipelist *) NULL)) == NULL)
		415	return;
		416
		417	if ((tmp = attempt_recipe (op, cauldron, 1, rp, -1)))
		418	{
		419	if (!tmp->flag [FLAG_CURSED]) /* curse it */
		420	tmp->set_flag (FLAG_CURSED);
		421
		422	/* the apply code for potions already deals with cursed
		423	* potions, so any code here is basically ignored.
		424	*/
		425	if (tmp->type == FOOD)
		426	{
		427	tmp->stats.hp = random_roll (0, 149, op, PREFER_LOW);
		428	}
		429	tmp->value = 0; /* unsaleable item */
		430
		431	/* change stats downward */
		432	do
		433	{
		434	change_attr_value (&tmp->stats, rndm (0, 6), -1 * (rndm (1, 3)));
		435	}
		436	while (rndm (0, 2));
		437	}
		438	return;
		439	}
		440
		441	if (level == 40)
		442	{ /* MAKE RANDOM RECIPE */
		443	recipelist *fl;
		444	int numb = numb_ob_inside (cauldron);
		445
		446	fl = get_formulalist (numb - 1); /* take a lower recipe list */
		447	if (fl && (rp = get_random_recipe (fl)))
		448	/* even though random, don't grant user any EXP for it */
		449	attempt_recipe (op, cauldron, 1, rp, -1);
		450	else
		451	alchemy_failure_effect (op, cauldron, rp, level - 1);
		452	}
		453	else if (level < 45)
		454	{ /* INFURIATE NPC's */
		455	/* this is kind of kludgy I know... */
		456	cauldron->enemy = op;
		457	npc_call_help (cauldron);
		458	cauldron->enemy = NULL;
		459
		460	alchemy_failure_effect (op, cauldron, rp, level - 5);
		461	}
		462	else if (level < 50)
		463	{ /* MINOR EXPLOSION/FIREBALL */
		464	object *tmp;
		465
		466	remove_contents (cauldron->inv, NULL);
		467	switch (rndm (0, 2))
		468	{
		469	case 0:
		470	tmp = archetype::get (shstr_bomb);
		471	tmp->stats.dam = random_roll (1, level, op, PREFER_LOW);
		472	tmp->stats.hp = random_roll (1, level, op, PREFER_LOW);
		473	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s creates a bomb!", &cauldron->name);
		474	break;
		475
		476	default:
		477	tmp = archetype::get (shstr_fireball);
		478	tmp->stats.dam = random_roll (1, level, op, PREFER_LOW) / 5 + 1;
		479	tmp->stats.hp = random_roll (1, level, op, PREFER_LOW) / 10 + 2;
		480	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s erupts in flame!", &cauldron->name);
		481	break;
		482	}
		483
		484	tmp->insert_at (cauldron);
		485	}
		486	else if (level < 60)
		487	{ /* CREATE MONSTER */
		488	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s %s.", &cauldron->name, cauldron_sound ());
		489	remove_contents (cauldron->inv, NULL);
		490	}
		491	else if (level < 80)
		492	{ /* MAJOR FIRE */
		493	object *fb = archetype::get (SP_MED_FIREBALL);
		494
		495	remove_contents (cauldron->inv, NULL);
		496	fire_arch_from_position (cauldron, cauldron, cauldron->x, cauldron->y, 0, fb);
		497	fb->destroy ();
		498	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s erupts in flame!", &cauldron->name);
		499	}
		500	else if (level < 100)
		501	{ /* WHAMMY the CAULDRON */
		502	if (!cauldron->flag [FLAG_CURSED])
		503	cauldron->set_flag (FLAG_CURSED);
		504	else
		505	cauldron->magic--;
		506
		507	cauldron->magic -= random_roll (0, 4, op, PREFER_LOW);
		508
		509	if (rndm (0, 1))
		510	{
		511	remove_contents (cauldron->inv, NULL);
		512	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s turns darker then makes a gulping sound!", &cauldron->name);
		513	}
		514	else
		515	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s becomes darker.", &cauldron->name);
		516	}
		517	else if (level < 110)
		518	{ /* SUMMON EVIL MONSTERS */
		519	object *tmp = get_random_mon (level / 5);
		520
		521	remove_contents (cauldron->inv, NULL);
		522
		523	if (!tmp)
		524	alchemy_failure_effect (op, cauldron, rp, level);
		525	else if (summon_hostile_monsters (cauldron, random_roll (1, 10, op, PREFER_LOW), tmp->arch->archname))
		526	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s %s and then pours forth monsters!", &cauldron->name, cauldron_sound ());
		527	}
		528	else if (level < 150)
		529	{ /* COMBO EFFECT */
		530	int roll = rndm (1, 3);
		531
		532	while (roll)
		533	{
		534	alchemy_failure_effect (op, cauldron, rp, level - 39);
		535	roll--;
		536	}
		537	}
		538	else if (level == 151)
		539	{ /* CREATE RANDOM ARTIFACT */
		540	object *tmp;
		541
		542	/* this is meant to be better than prior possiblity,
		543	* in this one, we allow *any* valid alchemy artifact
		544	* to be made (rather than only those on the given
		545	* formulalist) */
		546	if (!rp)
		547	rp = get_random_recipe ((recipelist *) NULL);
		548
		549	if (rp && (tmp = archetype::get (rp->arch_name [rndm (rp->arch_names)])))
		550	{
		551	generate_artifact (tmp, random_roll (1, op->level / 2 + 1, op, PREFER_HIGH) + 1);
		552	if ((tmp = insert_ob_in_ob (tmp, cauldron)))
		553	{
		554	remove_contents (cauldron->inv, tmp);
		555	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s %s.", &cauldron->name, cauldron_sound ());
		556	}
		557	}
		558	}
		559	else
		560	{ /* MANA STORM - watch out!! */
		561	object *tmp = archetype::get (LOOSE_MANA);
		562
		563	new_draw_info (NDI_UNIQUE, 0, op, "You unwisely release potent forces!");
		564	remove_contents (cauldron->inv, NULL);
		565	cast_magic_storm (op, tmp, level);
		566	}
		567	}
		568
		569	/**
		570	*"Danger" level, will determine how bad the backfire
		571	* could be if the user fails to concoct a recipe properly. Factors include
		572	* the number of ingredients, the length of the name of each ingredient,
		573	* the user's effective level, the user's Int and the enchantment on the
		574	* mixing device (aka "cauldron"). Higher values of 'danger' indicate more
		575	* danger. Note that we assume that we have had the caster ready the alchemy
		576	* skill *before* this routine is called. (no longer auto-readies that skill)
		577	* -b.t.
		578	*/
		579	static int
		580	calc_alch_danger (object *caster, object *cauldron, object *skill, recipe *rp)
		581	{
		582	int danger = 0;
		583
		584	/* Knowing alchemy skill reduces yer risk */
		585	danger -= skill->level;
		586
		587	/* better cauldrons reduce risk */
		588	danger -= cauldron->magic;
		589
		590	/* Higher Int, lower the risk */
		591	danger -= 3 * (caster->stats.Int - 15);
		592
		593	/* Ingredients. Longer names usually mean rarer stuff.
		594	* Thus the backfire is worse. Also, more ingredients
		595	* means we are attempting a more powerfull potion,
		596	* and thus the backfire will be worse. */
		597	for (object *item = cauldron->inv; item; item = item->below)
		598	{
		599	const char *name = item->title
		600	? format ("%s %s", &item->name, &item->title)
		601	: &item->name;
		602
		603	danger += strtoint (name) / 1000 + 3;
		604	}
		605
		606	if (!rp)
		607	danger += 110;
		608	else
		609	danger += rp->diff * 3;
		610
		611	/* Using a bad device is *majorly* stupid */
		612	if (cauldron->flag [FLAG_CURSED]) danger += 80;
		613	if (cauldron->flag [FLAG_DAMNED]) danger += 200;
		614
		615	#ifdef ALCHEMY_DEBUG
		616	LOG (llevDebug, "calc_alch_danger() returned danger=%d\n", danger);
		617	#endif
		618
		619	return danger;
		620	}
		621
		622	/**
		623	* Determines if ingredients in a container match the
		624	* proper ingredients for a recipe.
		625	*
		626	* rp is the recipe to check
		627	* cauldron is the container that holds the ingredients
		628	* returns 1 if the ingredients match the recipe, 0 if not
		629	*
		630	* This functions tries to find each defined ingredient in the container. It is
		631	* the defined recipe iff
		632	* - the number of ingredients of the recipe and in the container is equal
		633	* - all ingredients of the recipe are found in the container
		634	* - the number of batches is the same for all ingredients
		635	*/
		636	static int
		637	is_defined_recipe (const recipe *rp, const object *cauldron, object *caster)
		638	{
		639	uint32 batches_in_cauldron;
		640	const linked_char *ingredient;
		641	int number;
		642	const object *ob;
		643
		644	/* check for matching number of ingredients */
		645	number = 0;
		646	for (ingredient = rp->ingred; ingredient != NULL; ingredient = ingredient->next)
		647	number++;
		648	for (ob = cauldron->inv; ob != NULL; ob = ob->below)
		649	number--;
		650	if (number != 0)
		651	return 0;
		652
		653	/* check for matching ingredients */
		654	batches_in_cauldron = 0;
		655	for (ingredient = rp->ingred; ingredient != NULL; ingredient = ingredient->next)
		656	{
		657	uint32 nrof;
		658	const char *name;
		659	int ok;
		660
		661	/* determine and remove nrof from name */
		662	name = ingredient->name;
		663	nrof = 0;
		664	while (isdigit (*name))
		665	{
		666	nrof = 10 * nrof + (*name - '0');
		667	name++;
		668	}
		669	if (nrof == 0)
		670	nrof = 1;
		671	while (*name == ' ')
		672	name++;
		673
		674	/* find the current ingredient in the cauldron */
		675	ok = 0;
		676	for (ob = cauldron->inv; ob != NULL; ob = ob->below)
		677	{
		678	char name_ob[MAX_BUF];
		679	const char *name2;
		680
		681	if (!ob->title)
		682	name2 = ob->name;
		683	else
		684	{
		685	snprintf (name_ob, sizeof (name_ob), "%s %s", &ob->name, &ob->title);
		686	name2 = name_ob;
		687	}
		688
		689	if (strcmp (name2, name) == 0)
		690	{
		691	if (ob->nrof % nrof == 0)
		692	{
		693	uint32 batches;
		694
		695	batches = ob->nrof / nrof;
		696	if (batches_in_cauldron == 0)
		697	{
		698	batches_in_cauldron = batches;
		699	ok = 1;
		700	}
		701	else if (batches_in_cauldron == batches)
		702	ok = 1;
		703	}
		704	break;
		705	}
		706	}
		707	if (!ok)
		708	return (0);
		709	}
		710
		711	return (1);
		712	}
		713
		714	/**
		715	* Find a recipe from a recipe list that matches the given formula. If there
		716	* is more than one matching recipe, it selects a random one. If at least one
		717	* transmuting recipe matches, it only considers matching transmuting recipes.
		718	*
		719	* @return one matching recipe, or NULL if no recipe matches
		720	*/
		721	static recipe *
		722	find_recipe (recipelist * fl, int formula, object *ingredients)
		723	{
		724	recipe *rp;
		725	recipe *result; /* winning recipe, or NULL if no recipe found */
		726	int recipes_matching; /* total number of matching recipes so far */
		727	int transmute_found; /* records whether a transmuting recipe was found so far */
		728	size_t rp_arch_index;
		729
		730	#ifdef EXTREME_ALCHEMY_DEBUG
		731	LOG (llevDebug, "looking for formula %d:\n", formula);
		732	#endif
		733	result = NULL;
		734	recipes_matching = 0;
		735	transmute_found = 0;
		736
		737	for (rp = fl->items; rp; rp = rp->next)
		738	{
		739	/* check if recipe matches at all */
		740	if (formula % rp->index != 0)
		741	{
		742	#ifdef EXTREME_ALCHEMY_DEBUG
		743	LOG (llevDebug, " formula %s of %s (%d) does not match\n", rp->arch_name[0], &rp->title, rp->index);
		744	#endif
		745	continue;
		746	}
		747
		748	if (rp->transmute && find_transmution_ob (ingredients, rp, &rp_arch_index, 0) != NULL)
		749	{
		750	#ifdef EXTREME_ALCHEMY_DEBUG
		751	LOG (llevDebug, " formula %s of %s (%d) is a matching transmuting formula\n", rp->arch_name[rp_arch_index], &rp->title, rp->index);
		752	#endif
		753	/* transmution recipe with matching base ingredient */
		754	if (!transmute_found)
		755	{
		756	transmute_found = 1;
		757	recipes_matching = 0;
		758	}
		759	}
		760	else if (transmute_found)
		761	{
		762	#ifdef EXTREME_ALCHEMY_DEBUG
		763	LOG (llevDebug, " formula %s of %s (%d) matches but is not a matching transmuting formula\n", rp->arch_name[0], &rp->title,
		764	rp->index);
		765	#endif
		766	/* "normal" recipe found after previous transmution recipe => ignore this recipe */
		767	continue;
		768	}
		769	#ifdef EXTREME_ALCHEMY_DEBUG
		770	else
		771	{
		772	LOG (llevDebug, " formula %s of %s (%d) matches\n", rp->arch_name[0], &rp->title, rp->index);
		773	}
		774	#endif
		775
		776	if (rndm (0, recipes_matching) == 0)
		777	result = rp;
		778
		779	recipes_matching++;
		780	}
		781
		782	if (result == NULL)
		783	{
		784	#ifdef ALCHEMY_DEBUG
		785	LOG (llevDebug, "couldn't find formula for ingredients.\n");
		786	#endif
		787	return NULL;
		788	}
		789
		790	#ifdef ALCHEMY_DEBUG
		791	if (strcmp (result->title, "NONE") != 0)
		792	LOG (llevDebug, "got formula: %s of %s (nbatches:%d)\n", result->arch_name[0], &result->title, formula / result->index);
		793	else
		794	LOG (llevDebug, "got formula: %s (nbatches:%d)\n", result->arch_name[0], formula / result->index);
		795	#endif
		796	return result;
		797	}
		798
		799	/**
75	* Main part of the ALCHEMY code. From this we call fctns	800	* Main part of the ALCHEMY code. From this we call fctns
76	* that take a look at the contents of the 'cauldron' and, using these ingredients,	801	* that take a look at the contents of the 'cauldron' and, using these ingredients,
77	* we construct an integer formula value which is referenced (randomly) against a	802	* we construct an integer formula value which is referenced (randomly) against a
78	* formula list (the formula list chosen is based on the # contents of the cauldron).	803	* formula list (the formula list chosen is based on the # contents of the cauldron).
79	*	804	*
…		…
92	* There is no good reason (in my mind) why alchemical processes have to be	817	* There is no good reason (in my mind) why alchemical processes have to be
93	* unique -- such a 'feature' is one reason why players might want to experiment	818	* unique -- such a 'feature' is one reason why players might want to experiment
94	* around. :)	819	* around. :)
95	* -b.t.	820	* -b.t.
96	*/	821	*/
97
98	void	822	void
99	attempt_do_alchemy (object *caster, object *cauldron, object *skill)	823	attempt_do_alchemy (object *caster, object *cauldron, object *skill)
100	{	824	{
101	recipelist *fl;	825	recipelist *fl;
102	recipe *rp = NULL;	826	recipe *rp = NULL;
…		…
120	return;	844	return;
121		845
122	numb = numb_ob_inside (cauldron);	846	numb = numb_ob_inside (cauldron);
123	if ((fl = get_formulalist (numb)))	847	if ((fl = get_formulalist (numb)))
124	{	848	{
125	if (QUERY_FLAG (caster, FLAG_WIZ))	849	if (caster->flag [FLAG_WIZ])
126	{	850	{
127	rp = find_recipe (fl, formula, cauldron->inv);	851	rp = find_recipe (fl, formula, cauldron->inv);
128	if (rp != NULL)	852	if (rp != NULL)
129	{	853	{
130	#ifdef ALCHEMY_DEBUG	854	#ifdef ALCHEMY_DEBUG
131	if (strcmp (rp->title, "NONE"))	855	if (strcmp (rp->title, "NONE"))
132	LOG (llevDebug, "WIZ got formula: %s of %s\n", rp->arch_name[0], rp->title);	856	LOG (llevDebug, "WIZ got formula: %s of %s\n", rp->arch_name[0], &rp->title);
133	else	857	else
134	LOG (llevDebug, "WIZ got formula: %s (nbatches:%d)\n", rp->arch_name[0], formula / rp->index);	858	LOG (llevDebug, "WIZ got formula: %s (nbatches:%d)\n", rp->arch_name[0], formula / rp->index);
135	#endif	859	#endif
136	attempt_recipe (caster, cauldron, ability, rp, formula / rp->index);	860	attempt_recipe (caster, cauldron, ability, rp, formula / rp->index);
137	}	861	}
…		…
150	uint64 value_ingredients;	874	uint64 value_ingredients;
151	uint64 value_item;	875	uint64 value_item;
152	object *tmp;	876	object *tmp;
153	int attempt_shadow_alchemy;	877	int attempt_shadow_alchemy;
154		878
155	ave_chance = fl->total_chance / (float) fl->number;	879	ave_chance = fl->total_chance / (float)fl->number;
156		880
157	ability += (int) (skill->level * ((4.0 + cauldron->magic) / 4.0));	881	ability += skill->level * ((4.0 + cauldron->magic) / 4.0);
158		882
159	/* determine value of ingredients */	883	/* determine value of ingredients */
160	value_ingredients = 0;	884	value_ingredients = 0;
161	for (tmp = cauldron->inv; tmp != NULL; tmp = tmp->below)	885	for (tmp = cauldron->inv; tmp; tmp = tmp->below)
162	value_ingredients += query_cost (tmp, NULL, F_TRUE);	886	value_ingredients += query_cost (tmp, NULL, F_TRUE);
163		887
164	attempt_shadow_alchemy = !is_defined_recipe (rp, cauldron, caster);	888	attempt_shadow_alchemy = !is_defined_recipe (rp, cauldron, caster);
165		889
166	/* create the object **FIRST**, then decide whether to keep it. */	890	/* create the object **FIRST**, then decide whether to keep it. */
167	if ((item = attempt_recipe (caster, cauldron, ability, rp, formula / rp->index)) != NULL)	891	if ((item = attempt_recipe (caster, cauldron, ability, rp, formula / rp->index)) != NULL)
168	{	892	{
169	/* compute base chance of recipe success */	893	/* compute base chance of recipe success */
170	success_chance = ((float) ability / (float) (rp->diff * (item->level + 2)));	894	success_chance = ((float)ability / (float)(rp->diff * (item->level + 2)));
171	if (ave_chance == 0)	895	if (ave_chance == 0)
172	ave_chance = 1;	896	ave_chance = 1;
173		897
174	#ifdef ALCHEMY_DEBUG	898	#ifdef ALCHEMY_DEBUG
175	LOG (llevDebug, "percent success chance = %f ab%d / diff%d*lev%d\n", success_chance, ability, rp->diff, item->level);	899	LOG (llevDebug, "percent success chance = %f ab%d / diff%d*lev%d\n", success_chance, ability, rp->diff, item->level);
…		…
183	"Forcing failure for shadow alchemy recipe because price of ingredients (%llu) is less than price of result (%llu).\n",	907	"Forcing failure for shadow alchemy recipe because price of ingredients (%llu) is less than price of result (%llu).\n",
184	value_ingredients, value_item);	908	value_ingredients, value_item);
185	#endif	909	#endif
186	}	910	}
187	/* roll the dice */	911	/* roll the dice */
188	else if ((float) (random_roll (0, 101, caster, PREFER_LOW)) <= 100.0 * success_chance)	912	else if (random_roll (0, 101, caster, PREFER_LOW) <= 100.0 * success_chance)
189	{	913	{
190	change_exp (caster, rp->exp, rp->skill, SK_EXP_NONE);	914	change_exp (caster, rp->exp, rp->skill, SK_EXP_NONE);
191		915
192	// let alchemy consume some time, so that exploits are less easy	916	// let alchemy consume some time, so that exploits are less easy
193	caster->speed_left -= 1.0;	917	caster->speed_left -= 1.0;
…		…
197	}	921	}
198	}	922	}
199	}	923	}
200		924
201	/* if we get here, we failed!! */	925	/* if we get here, we failed!! */
202	alchemy_failure_effect (caster, cauldron, rp, calc_alch_danger (caster, cauldron, rp));	926	alchemy_failure_effect (caster, cauldron, rp, calc_alch_danger (caster, cauldron, skill, rp));
203	}	927	}
204		928
205	/**
206	* Recipe value of the entire contents of a container.
207	* This appears to just generate a hash value, which I guess for now works
208	* ok, but the possibility of duplicate hashes is certainly possible - msw
209	*/
210
211	int
212	content_recipe_value (object *op)
213	{
214	char name[MAX_BUF];
215	object *tmp = op->inv;
216	int tval = 0, formula = 0;
217
218	while (tmp)
219	{
220	tval = 0;
221	assign (name, tmp->name);
222	if (tmp->title)
223	sprintf (name, "%s %s", &tmp->name, &tmp->title);
224	tval = (strtoint (name) * (tmp->nrof ? tmp->nrof : 1));
225	#ifdef ALCHEMY_DEBUG
226	LOG (llevDebug, "Got ingredient %d %s(%d)\n", tmp->nrof ? tmp->nrof : 1, name, tval);
227	#endif
228	formula += tval;
229	tmp = tmp->below;
230	}
231	#ifdef ALCHEMY_DEBUG
232	LOG (llevDebug, " Formula value=%d\n", formula);
233	#endif
234	return formula;
235	}
236
237	/**
238	* Returns total number of items in op
239	*/
240
241	int
242	numb_ob_inside (object *op)
243	{
244	object *tmp = op->inv;
245	int number = 0, o_number = 0;
246
247	while (tmp)
248	{
249	if (tmp->nrof)
250	number += tmp->nrof;
251	else
252	number++;
253	o_number++;
254	tmp = tmp->below;
255	}
256	#ifdef ALCHEMY_DEBUG
257	LOG (llevDebug, "numb_ob_inside(%s): found %d ingredients\n", op->name, o_number);
258	#endif
259	return o_number;
260	}
261
262	/**
263	* Essentially a wrapper for make_item_from_recipe() and
264	* insert_ob_in_ob. If the caster has some alchemy skill, then they might
265	* gain some exp from (successfull) fabrication of the product.
266	* If nbatches==-1, don't give exp for this creation (random generation/
267	* failed recipe)
268	*/
269
270	object *
271	attempt_recipe (object *caster, object *cauldron, int ability, recipe *rp, int nbatches)
272	{
273
274	object *item = NULL, *skop;
275
276	/* this should be passed to this fctn, not effiecent cpu use this way */
277	int batches = abs (nbatches);
278
279	/* is the cauldron the right type? */
280	if (rp->cauldron && rp->cauldron != cauldron->arch->archname)
281	return 0;
282
283	skop = find_skill_by_name (caster, rp->skill);
284	/* does the caster have the skill? */
285	if (!skop)
286	return 0;
287
288	/* code required for this recipe, search the caster */
289	if (rp->keycode)
290	{
291	object *tmp;
292
293	for (tmp = caster->inv; tmp; tmp = tmp->below)
294	{
295	if (tmp->type == FORCE && tmp->slaying && rp->keycode == tmp->slaying)
296	break;
297	}
298
299	if (!tmp)
300	{ /* failure--no code found */
301	new_draw_info (NDI_UNIQUE, 0, caster, "You know the ingredients, but not the technique. Go learn how to do this recipe.");
302	return 0;
303	}
304	}
305
306	#ifdef EXTREME_ALCHEMY_DEBUG
307	LOG (llevDebug, "attempt_recipe(): got %d nbatches\n", nbatches);
308	LOG (llevDebug, "attempt_recipe(): using recipe %s\n", rp->title ? rp->title : "unknown");
309	#endif
310
311	if ((item = make_item_from_recipe (cauldron, rp)) != NULL)
312	{
313	remove_contents (cauldron->inv, item);
314	/* Recalc carrying of the cauldron, in case recipe did not conserve mass */
315	cauldron->update_weight ();
316	/* adj lvl, nrof on caster level */
317	adjust_product (item, ability, rp->yield ? (rp->yield * batches) : batches);
318	if (!item->env && (item = insert_ob_in_ob (item, cauldron)) == NULL)
319	{
320	new_draw_info (NDI_UNIQUE, 0, caster, "Nothing happened.");
321	/* new_draw_info_format(NDI_UNIQUE, 0,caster,
322	"Your spell causes the %s to explode!",&cauldron->name); */
323	/* kaboom_cauldron(); */
324	}
325	else
326	new_draw_info_format (NDI_UNIQUE, 0, caster, "The %s %s.", &cauldron->name, cauldron_sound ());
327	}
328
329	return item;
330	}
331
332
333
334	/**
335	* We adjust the nrof, exp and level of the final product, based
336	* on the item's default parameters, and the relevant caster skill level.
337	*/
338	void
339	adjust_product (object *item, int lvl, int yield)
340	{
341	int nrof = 1;
342
343	if (!yield)
344	yield = 1;
345
346	if (lvl <= 0)
347	lvl = 1; /* lets avoid div by zero! */
348
349	if (item->nrof)
350	{
351	nrof = (int) ((1.0 - 1.0 / (lvl / 10.0 + 1.0)) * (rndm (0, yield - 1) + rndm (0, yield - 1) + rndm (0, yield - 1)) + 1);
352
353	if (nrof > yield)
354	nrof = yield;
355
356	item->nrof = nrof;
357	}
358	}
359
360
361	/**
362	* Using a list of items and a recipe to make an artifact.
363	*
364	* @param cauldron the cauldron (including the ingredients) used to make the item
365	*
366	* @param rp the recipe to make the artifact from
367	*
368	* @return the newly created object, NULL if something failed
369	*/
370
371	object *
372	make_item_from_recipe (object *cauldron, recipe *rp)
373	{
374	artifact *art = NULL;
375	object *item = NULL;
376	size_t rp_arch_index;
377
378	if (rp == NULL)
379	return (object *) NULL;
380
381	/* Find the appropriate object to transform... */
382	if ((item = find_transmution_ob (cauldron->inv, rp, &rp_arch_index, 1)) == NULL)
383	{
384	LOG (llevDebug, "make_alchemy_item(): failed to create alchemical object.\n");
385	return (object *) NULL;
386	}
387
388	/* Find the appropriate artifact template... */
389	if (rp->title != shstr_NONE)
390	{
391	if ((art = locate_recipe_artifact (rp, rp_arch_index)) == NULL)
392	{
393	LOG (llevError, "make_alchemy_item(): failed to locate recipe artifact.\n");
394	LOG (llevDebug, " --requested recipe: %s of %s.\n", rp->arch_name[0], &rp->title);
395	return (object *) NULL;
396	}
397
398	transmute_materialname (item, art->item);
399	give_artifact_abilities (item, art->item);
400	}
401
402	if (QUERY_FLAG (cauldron, FLAG_CURSED))
403	SET_FLAG (item, FLAG_CURSED);
404	if (QUERY_FLAG (cauldron, FLAG_DAMNED))
405	SET_FLAG (item, FLAG_DAMNED);
406
407	return item;
408	}
409
410
411	/**
412	* Looks through the ingredient list. If we find a
413	* suitable object in it - we will use that to make the requested artifact.
414	* Otherwise the code returns a 'generic' item if create_item is set. -b.t.
415	*
416	* @param rp_arch_index pointer to return value; set to arch index for recipe;
417	* set to zero if not using a transmution formula
418	*/
419
420	object *
421	find_transmution_ob (object *first_ingred, recipe *rp, size_t * rp_arch_index, int create_item)
422	{
423	object *item = NULL;
424
425	*rp_arch_index = 0;
426
427	if (rp->transmute) /* look for matching ingredient/prod archs */
428	for (item = first_ingred; item; item = item->below)
429	{
430	int i;
431
432	for (int i = 0; i < rp->arch_names; i++)
433	//TODO: should be a shstr comparison
434	if (&item->arch->archname == rp->arch_name[i])
435	{
436	*rp_arch_index = i;
437	break;
438	}
439
440	if (i < rp->arch_names)
441	break;
442	}
443
444	/* failed, create a fresh object. Note no nrof>1 because that would
445	* allow players to create massive amounts of artifacts easily */
446	if (create_item && (!item || item->nrof > 1))
447	{
448	*rp_arch_index = rndm (rp->arch_names);
449	item = get_archetype (rp->arch_name[*rp_arch_index]);
450	}
451
452	#ifdef ALCHEMY_DEBUG
453	LOG (llevDebug, "recipe calls for%stransmution.\n", rp->transmute ? " " : " no ");
454	if (item != NULL)
455	{
456	LOG (llevDebug, " find_transmutable_ob(): returns arch %s(sp:%d)\n", item->arch->name, item->stats.sp);
457	}
458	#endif
459
460	return item;
461	}
462
463
464	/**
465	* Ouch. We didnt get the formula we wanted.
466	* This fctn simulates the backfire effects--worse effects as the level
467	* increases. If SPELL_FAILURE_EFFECTS is defined some really evil things
468	* can happen to the would be alchemist. This table probably needs some
469	* adjustment for playbalance. -b.t.
470	*/
471
472	void
473	alchemy_failure_effect (object *op, object *cauldron, recipe *rp, int danger)
474	{
475	int level = 0;
476
477	if (!op || !cauldron)
478	return;
479
480	if (danger > 1)
481	level = random_roll (1, danger, op, PREFER_LOW);
482
483	#ifdef ALCHEMY_DEBUG
484	LOG (llevDebug, "Alchemy_failure_effect(): using level=%d\n", level);
485	#endif
486
487	/* possible outcomes based on level */
488	if (level < 25)
489	{ /* INGREDIENTS USED/SLAGGED */
490	object *item = NULL;
491
492	if (rndm (0, 2))
493	{ /* slag created */
494	object *tmp = cauldron->inv;
495	int weight = 0;
496
497	tmp = get_archetype ("rock");
498	tmp->weight = weight;
499	tmp->value = 0;
500	tmp->materialname = "stone";
501	tmp->name = "slag";
502	tmp->name_pl = "slags";
503	item = insert_ob_in_ob (tmp, cauldron);
504	CLEAR_FLAG (tmp, FLAG_CAN_ROLL);
505	CLEAR_FLAG (tmp, FLAG_NO_PICK);
506	tmp->move_block = 0;
507	}
508
509	remove_contents (cauldron->inv, item);
510	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s %s.", &cauldron->name, cauldron_sound ());
511	return;
512	}
513	else if (level < 40)
514	{ /* MAKE TAINTED ITEM */
515	object *tmp = NULL;
516
517	if (!rp)
518	if ((rp = get_random_recipe ((recipelist *) NULL)) == NULL)
519	return;
520
521	if ((tmp = attempt_recipe (op, cauldron, 1, rp, -1)))
522	{
523	if (!QUERY_FLAG (tmp, FLAG_CURSED)) /* curse it */
524	SET_FLAG (tmp, FLAG_CURSED);
525
526	/* the apply code for potions already deals with cursed
527	* potions, so any code here is basically ignored.
528	*/
529	if (tmp->type == FOOD)
530	{
531	tmp->stats.hp = random_roll (0, 149, op, PREFER_LOW);
532	}
533	tmp->value = 0; /* unsaleable item */
534
535	/* change stats downward */
536	do
537	{
538	change_attr_value (&tmp->stats, rndm (0, 6), -1 * (rndm (1, 3)));
539	}
540	while (rndm (0, 2));
541	}
542	return;
543	}
544
545	if (level == 40)
546	{ /* MAKE RANDOM RECIPE */
547	recipelist *fl;
548	int numb = numb_ob_inside (cauldron);
549
550	fl = get_formulalist (numb - 1); /* take a lower recipe list */
551	if (fl && (rp = get_random_recipe (fl)))
552	/* even though random, don't grant user any EXP for it */
553	(void) attempt_recipe (op, cauldron, 1, rp, -1);
554	else
555	alchemy_failure_effect (op, cauldron, rp, level - 1);
556	}
557	else if (level < 45)
558	{ /* INFURIATE NPC's */
559	/* this is kind of kludgy I know... */
560	cauldron->enemy = op;
561	npc_call_help (cauldron);
562	cauldron->enemy = NULL;
563
564	alchemy_failure_effect (op, cauldron, rp, level - 5);
565	}
566	else if (level < 50)
567	{ /* MINOR EXPLOSION/FIREBALL */
568	object *tmp;
569
570	remove_contents (cauldron->inv, NULL);
571	switch (rndm (0, 2))
572	{
573	case 0:
574	tmp = get_archetype ("bomb");
575	tmp->stats.dam = random_roll (1, level, op, PREFER_LOW);
576	tmp->stats.hp = random_roll (1, level, op, PREFER_LOW);
577	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s creates a bomb!", &cauldron->name);
578	break;
579
580	default:
581	tmp = get_archetype ("fireball");
582	tmp->stats.dam = random_roll (1, level, op, PREFER_LOW) / 5 + 1;
583	tmp->stats.hp = random_roll (1, level, op, PREFER_LOW) / 10 + 2;
584	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s erupts in flame!", &cauldron->name);
585	break;
586	}
587
588	tmp->insert_at (cauldron);
589	}
590	else if (level < 60)
591	{ /* CREATE MONSTER */
592	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s %s.", &cauldron->name, cauldron_sound ());
593	remove_contents (cauldron->inv, NULL);
594	}
595	else if (level < 80)
596	{ /* MAJOR FIRE */
597	object *fb = get_archetype (SP_MED_FIREBALL);
598
599	remove_contents (cauldron->inv, NULL);
600	fire_arch_from_position (cauldron, cauldron, cauldron->x, cauldron->y, 0, fb);
601	fb->destroy ();
602	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s erupts in flame!", &cauldron->name);
603	}
604	else if (level < 100)
605	{ /* WHAMMY the CAULDRON */
606	if (!QUERY_FLAG (cauldron, FLAG_CURSED))
607	SET_FLAG (cauldron, FLAG_CURSED);
608	else
609	cauldron->magic--;
610
611	cauldron->magic -= random_roll (0, 4, op, PREFER_LOW);
612
613	if (rndm (0, 1))
614	{
615	remove_contents (cauldron->inv, NULL);
616	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s turns darker then makes a gulping sound!", &cauldron->name);
617	}
618	else
619	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s becomes darker.", &cauldron->name);
620	}
621	else if (level < 110)
622	{ /* SUMMON EVIL MONSTERS */
623	object *tmp = get_random_mon (level / 5);
624
625	remove_contents (cauldron->inv, NULL);
626
627	if (!tmp)
628	alchemy_failure_effect (op, cauldron, rp, level);
629	else if (summon_hostile_monsters (cauldron, random_roll (1, 10, op, PREFER_LOW), tmp->arch->archname))
630	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s %s and then pours forth monsters!", &cauldron->name, cauldron_sound ());
631	}
632	else if (level < 150)
633	{ /* COMBO EFFECT */
634	int roll = rndm (1, 3);
635
636	while (roll)
637	{
638	alchemy_failure_effect (op, cauldron, rp, level - 39);
639	roll--;
640	}
641	}
642	else if (level == 151)
643	{ /* CREATE RANDOM ARTIFACT */
644	object *tmp;
645
646	/* this is meant to be better than prior possiblity,
647	* in this one, we allow *any* valid alchemy artifact
648	* to be made (rather than only those on the given
649	* formulalist) */
650	if (!rp)
651	rp = get_random_recipe ((recipelist *) NULL);
652
653	if (rp && (tmp = get_archetype (rp->arch_name [rndm (rp->arch_names)])))
654	{
655	generate_artifact (tmp, random_roll (1, op->level / 2 + 1, op, PREFER_HIGH) + 1);
656	if ((tmp = insert_ob_in_ob (tmp, cauldron)))
657	{
658	remove_contents (cauldron->inv, tmp);
659	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s %s.", &cauldron->name, cauldron_sound ());
660	}
661	}
662	}
663	else
664	{ /* MANA STORM - watch out!! */
665	object *tmp = get_archetype (LOOSE_MANA);
666
667	new_draw_info (NDI_UNIQUE, 0, op, "You unwisely release potent forces!");
668	remove_contents (cauldron->inv, NULL);
669	cast_magic_storm (op, tmp, level);
670	}
671	}
672
673	/*
674	* All but object "save_item" are elimentated from
675	* the container list. Note we have to becareful to remove the inventories
676	* of objects in the cauldron inventory (ex icecube has stuff in it).
677	*/
678	void
679	remove_contents (object *first_ob, object *save_item)
680	{
681	// this cries for a cleaner rewrite, removing save_item first possibly
682	object *next, *tmp = first_ob;
683
684	while (tmp)
685	{
686	next = tmp->below;
687
688	if (tmp == save_item)
689	{
690	if (!(tmp = next))
691	break;
692	else
693	next = next->below;
694	}
695
696	if (tmp->inv)
697	remove_contents (tmp->inv, NULL);
698
699	tmp->destroy ();
700	tmp = next;
701	}
702	}
703
704	/**
705	*"Danger" level, will determine how bad the backfire
706	* could be if the user fails to concoct a recipe properly. Factors include
707	* the number of ingredients, the length of the name of each ingredient,
708	* the user's effective level, the user's Int and the enchantment on the
709	* mixing device (aka "cauldron"). Higher values of 'danger' indicate more
710	* danger. Note that we assume that we have had the caster ready the alchemy
711	* skill *before* this routine is called. (no longer auto-readies that skill)
712	* -b.t.
713	*/
714	int
715	calc_alch_danger (object *caster, object *cauldron, recipe *rp)
716	{
717	object *item;
718	char name[MAX_BUF];
719	int danger = 0, nrofi = 0;
720
721	/* Knowing alchemy skill reduces yer risk */
722	danger -= caster->chosen_skill ? caster->chosen_skill->level : caster->level;
723
724	if (!caster->chosen_skill)
725	LOG (llevError | logBacktrace, "calc_alch_danger called without a chosen skill, caster %s, cauldron %s\n",
726	caster->debug_desc (), cauldron->debug_desc ());
727
728	/* better cauldrons reduce risk */
729	danger -= cauldron->magic;
730
731	/* Higher Int, lower the risk */
732	danger -= 3 * (caster->stats.Int - 15);
733
734	/* Ingredients. Longer names usually mean rarer stuff.
735	* Thus the backfire is worse. Also, more ingredients
736	* means we are attempting a more powerfull potion,
737	* and thus the backfire will be worse. */
738	for (item = cauldron->inv; item; item = item->below)
739	{
740	assign (name, item->name);
741	if (item->title)
742	sprintf (name, "%s %s", &item->name, &item->title);
743	danger += (strtoint (name) / 1000) + 3;
744	nrofi++;
745	}
746
747	if (rp == NULL)
748	danger += 110;
749	else
750	danger += rp->diff * 3;
751
752	/* Using a bad device is *majorly* stupid */
753	if (QUERY_FLAG (cauldron, FLAG_CURSED))
754	danger += 80;
755	if (QUERY_FLAG (cauldron, FLAG_DAMNED))
756	danger += 200;
757
758	#ifdef ALCHEMY_DEBUG
759	LOG (llevDebug, "calc_alch_danger() returned danger=%d\n", danger);
760	#endif
761
762	return danger;
763	}
764
765	/**
766	* Determines if ingredients in a container match the
767	* proper ingredients for a recipe.
768	*
769	* rp is the recipe to check
770	* cauldron is the container that holds the ingredients
771	* returns 1 if the ingredients match the recipe, 0 if not
772	*
773	* This functions tries to find each defined ingredient in the container. It is
774	* the defined recipe iff
775	* - the number of ingredients of the recipe and in the container is equal
776	* - all ingredients of the recipe are found in the container
777	* - the number of batches is the same for all ingredients
778	*/
779	static int
780	is_defined_recipe (const recipe *rp, const object *cauldron, object *caster)
781	{
782	uint32 batches_in_cauldron;
783	const linked_char *ingredient;
784	int number;
785	const object *ob;
786
787	/* check for matching number of ingredients */
788	number = 0;
789	for (ingredient = rp->ingred; ingredient != NULL; ingredient = ingredient->next)
790	number++;
791	for (ob = cauldron->inv; ob != NULL; ob = ob->below)
792	number--;
793	if (number != 0)
794	return 0;
795
796	/* check for matching ingredients */
797	batches_in_cauldron = 0;
798	for (ingredient = rp->ingred; ingredient != NULL; ingredient = ingredient->next)
799	{
800	uint32 nrof;
801	const char *name;
802	int ok;
803
804	/* determine and remove nrof from name */
805	name = ingredient->name;
806	nrof = 0;
807	while (isdigit (*name))
808	{
809	nrof = 10 * nrof + (*name - '0');
810	name++;
811	}
812	if (nrof == 0)
813	nrof = 1;
814	while (*name == ' ')
815	name++;
816
817	/* find the current ingredient in the cauldron */
818	ok = 0;
819	for (ob = cauldron->inv; ob != NULL; ob = ob->below)
820	{
821	char name_ob[MAX_BUF];
822	const char *name2;
823
824	if (!ob->title)
825	name2 = ob->name;
826	else
827	{
828	snprintf (name_ob, sizeof (name_ob), "%s %s", &ob->name, &ob->title);
829	name2 = name_ob;
830	}
831
832	if (strcmp (name2, name) == 0)
833	{
834	if (ob->nrof % nrof == 0)
835	{
836	uint32 batches;
837
838	batches = ob->nrof / nrof;
839	if (batches_in_cauldron == 0)
840	{
841	batches_in_cauldron = batches;
842	ok = 1;
843	}
844	else if (batches_in_cauldron == batches)
845	ok = 1;
846	}
847	break;
848	}
849	}
850	if (!ok)
851	return (0);
852	}
853
854	return (1);
855	}
856
857	/**
858	* Find a recipe from a recipe list that matches the given formula. If there
859	* is more than one matching recipe, it selects a random one. If at least one
860	* transmuting recipe matches, it only considers matching transmuting recipes.
861	*
862	* @return one matching recipe, or NULL if no recipe matches
863	*/
864	static recipe *
865	find_recipe (recipelist * fl, int formula, object *ingredients)
866	{
867	recipe *rp;
868	recipe *result; /* winning recipe, or NULL if no recipe found */
869	int recipes_matching; /* total number of matching recipes so far */
870	int transmute_found; /* records whether a transmuting recipe was found so far */
871	size_t rp_arch_index;
872
873	#ifdef EXTREME_ALCHEMY_DEBUG
874	LOG (llevDebug, "looking for formula %d:\n", formula);
875	#endif
876	result = NULL;
877	recipes_matching = 0;
878	transmute_found = 0;
879
880	for (rp = fl->items; rp; rp = rp->next)
881	{
882	/* check if recipe matches at all */
883	if (formula % rp->index != 0)
884	{
885	#ifdef EXTREME_ALCHEMY_DEBUG
886	LOG (llevDebug, " formula %s of %s (%d) does not match\n", rp->arch_name[0], rp->title, rp->index);
887	#endif
888	continue;
889	}
890
891	if (rp->transmute && find_transmution_ob (ingredients, rp, &rp_arch_index, 0) != NULL)
892	{
893	#ifdef EXTREME_ALCHEMY_DEBUG
894	LOG (llevDebug, " formula %s of %s (%d) is a matching transmuting formula\n", rp->arch_name[rp_arch_index], rp->title, rp->index);
895	#endif
896	/* transmution recipe with matching base ingredient */
897	if (!transmute_found)
898	{
899	transmute_found = 1;
900	recipes_matching = 0;
901	}
902	}
903	else if (transmute_found)
904	{
905	#ifdef EXTREME_ALCHEMY_DEBUG
906	LOG (llevDebug, " formula %s of %s (%d) matches but is not a matching transmuting formula\n", rp->arch_name[0], rp->title,
907	rp->index);
908	#endif
909	/* "normal" recipe found after previous transmution recipe => ignore this recipe */
910	continue;
911	}
912	#ifdef EXTREME_ALCHEMY_DEBUG
913	else
914	{
915	LOG (llevDebug, " formula %s of %s (%d) matches\n", rp->arch_name[0], rp->title, rp->index);
916	}
917	#endif
918
919	if (rndm (0, recipes_matching) == 0)
920	result = rp;
921
922	recipes_matching++;
923	}
924
925	if (result == NULL)
926	{
927	#ifdef ALCHEMY_DEBUG
928	LOG (llevDebug, "couldn't find formula for ingredients.\n");
929	#endif
930	return NULL;
931	}
932
933	#ifdef ALCHEMY_DEBUG
934	if (strcmp (result->title, "NONE") != 0)
935	LOG (llevDebug, "got formula: %s of %s (nbatches:%d)\n", result->arch_name[0], result->title, formula / result->index);
936	else
937	LOG (llevDebug, "got formula: %s (nbatches:%d)\n", result->arch_name[0], formula / result->index);
938	#endif
939	return result;
940	}

Diff Legend

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