sorcery  Check-in [cb09c77754]

-- a rune is an abstract object created by a runeforge, which can be
-- applied to an amulet in order to imbue that amulet with unique
-- and fearsome powers. the specific spell depends on the stone the
-- rune is applied to, and not all runes can necessarily be applied
-- to all stones.


local sparkle_region = function(s)
	s.spell.visual_subjects {
		amount = s.amt, time = s.time, -- attached = s;
		minpos = s.minpos;
		maxpos = s.maxpos;
		minvel = { x = -0.4, y = -0.2, z = -0.4 };
		maxvel = { x =  0.4, y =  0.2, z =  0.4 };
................................................................................
	sorcery.spell.disjoin{target=target}
end

return {
	translocate = {
		name = 'Translocate';
		tone = {0,235,233};
		minpower = 3;
		rarity = 7;
		amulets = {
			amethyst = {
				name = 'Joining';
				desc = 'Give this amulet to another and with a snap of their fingers they can arrive safely at your side from anywhere in the world — though returning whence they came may be a more difficult matter';
				apply = function(ctx)
					local maker = ctx.user:get_player_name()
					ctx.meta:set_string('rune_join_target',maker)
................................................................................
			};
		};
	};
	disjoin = {
		name = 'Disjoin';
		tone = {159,235,0};
		minpower = 4;
		rarity = 34;
		amulets = {
			sapphire = {
				name = 'Unsealing';
				desc = 'Wielding this amulet, a touch of your hand will unravel even the mightiest protective magics, leaving doors unsealed and walls free to tear down';

				cast = function(ctx)
					if ctx.target.type ~= 'node' then return false end
					local r = 2 + math.floor(ctx.stats.power / 2)
					local cast = false
					for x = -r,r do
					for y = -r,r do
					for z = -r,r do
................................................................................
					end
					return cast
				end;
			};
			amethyst = {
				name = 'Purging';
				desc = 'Free yourself from the grip of any malicious spellwork with a snap of your fingers — interrupting all of your own active spells in the process, including impending translocations';

				cast = function(ctx) purge(ctx.caster) end;
			};
			emerald = {
				name = 'Disjunction Field';
				desc = 'Render an area totally opaque to spellwork for a period of time, disrupting any existing spells and preventing further spellcasting therein';

			};
			ruby = {
				name = 'Disjunction';
				desc = 'Wield this amulet against a spellcaster to disrupt and abort all their spells in progress, perhaps to trap a foe intent on translocating away, or unleash its force upon the victim of a malign hex to free them from its clutches';
				mingrade = 3;

				cast = function(ctx)
					if ctx.target.type == 'object'
						then purge(ctx.target.ref)
						else return false
					end
				end;
				frame = {
................................................................................
						desc = 'Not only will your victim\'s spells be nullified, but all enchanted objects they carry will be stripped of their power — or possibly even destroyed outright';
					};
				};
			};
			luxite = {
				name = 'Disjunctive Aura';
				desc = 'For a time, all magic undertaken in your vicinity will fail totally — including your own';

				cast = function(ctx)
					local h = ctx.heading.eyeheight*1.1
					sorcery.spell.cast {
						name = 'sorcery:disjunctive-aura';
						caster = ctx.caster, attach = 'caster';
						subjects = {{player=ctx.caster}};
						disjunction = true, range = 4 + ctx.stats.power;
................................................................................
									minpos = { x = 0-range, y = -0.5, z = 0-range };
									maxpos = { x =   range, y = h,    z =   range };
									img = sorcery.lib.image('sorcery_flicker.png'):glow(sorcery.lib.color(120,255,30));
								}
							end;
						};
						sounds = {
							[0.00] = {sound='sorcery_disjoin',   where='caster'};
							[{whence=0,secs=0.8}] = {
								sound='sorcery_disjoin_bg', where='subjects';
								gain=0.5, stop = {whence=1,secs=-1.5}
							};
							[1.00] = {sound='sorcery_powerdown', where='caster'};
						};
					}
				end
			};
			diamond = {
				name = 'Mundanity';
				desc = 'Strip away the effects of all active potions and spells in your immediate vicinity, leaving adversaries without their magicks to enhance and protect them, and allies free of any curses they may be hobbled by -- and, of course, vice versa';

				cast = function(ctx)
					local where = ctx.caster:get_pos()
					local what = minetest.get_objects_inside_radius(where, 3 + (2*ctx.stats.power))
					local who = {}
					local pfac = math.min(1, ctx.stats.power/8)
					for _, w in pairs(what) do
						if w:is_player() and w ~= ctx.caster then
................................................................................
						};
					}
				end;
				frame = {
					iridium = {
						name = 'Spellshatter';
						desc = 'Blast out a tidal wave of anti-magic that will nullify active spells, but also disenchant or destroy all magical items in range of its violently mundane grip';

						cast = function(ctx)
							local where = ctx.caster:get_pos()
							local radius = 3 + (2*ctx.stats.power)
							local what = minetest.get_objects_inside_radius(where, radius)
							local who = {}
							local pfac = math.min(1, ctx.stats.power/8)
							for _, w in pairs(what) do
................................................................................
											minsize = 0.7, maxsize = 2;
											animation = {
												type = 'vertical_frames', length = (21/6) + 0.1;
												aspect_w = 16, aspect_h = 16;
											}
										}
									end;






								};
								intervals = {
									{period = 0.1, after = 0.15, fn = function(c)
										for i = 1,80 do
											local life = 0.2 + math.random() * 2
											local dir = vector.new(math.random()-0.5,0,math.random()-0.5):normalize()
											local pos = epicenter + (dir * (math.random()*radius))
................................................................................
												}
											}
										end
										if next(wreck) then
											local k,p = sorcery.lib.tbl.pick(wreck)

											minetest.add_particle {
												texture = sorcery.lib.image('sorcery_sparking.png'):glow(sorcery.lib.color(255,0,0)):render();
												pos = vector.offset(p,math.random(),math.random(),math.random());
												expirationtime = 1;
												size = 5 + math.random() * 4;
												glow = 14;
												animation = {
													type = 'vertical_frames', length = 0.3;
													aspect_w = 64, aspect_h = 64;
												}
											}
											minetest.add_particle {
												texture = sorcery.lib.image('sorcery_crackle.png'):glow(sorcery.lib.color(255,0,0)):render();
												pos = vector.offset(p,math.random(),math.random(),math.random());
												expirationtime = 1;
												size = 4 + math.random() * 6;
												glow = 14;
												animation = {
													type = 'vertical_frames', length = 0.6;
													aspect_w = 64, aspect_h = 64;
												}
											}











































										end
									end};
								};
							}
						end;
					};
				};
................................................................................
			};
		}
	};
	repulse = {
		name = 'Repulse';
		tone = {0,180,235};
		minpower = 1;
		rarity = 5;
		amulets = {
			amethyst = {
				name = 'Hurling';
				desc = 'Wielding this amulet, a mere flick of your fingers will lift any target of your choice bodily into the air and press upon them with tremendous repulsive force, throwing them like a hapless ragdoll out of your path';
				cast = function(ctx)
					if not (ctx.target and ctx.target.type == 'object') then return false end
					local tgt = ctx.target.ref
					local line = vector.subtract(ctx.caster:get_pos(), tgt:get_pos())
					-- direction vector from target to caster
					local dir,mag = sorcery.lib.math.vsep(line)
					if mag > 6 then return false end -- no cheating!
					local force = 20 + (ctx.stats.power * 2.5)
					minetest.sound_play('sorcery_hurl',{pos=tgt:get_pos()},true)


					local immortal = tgt:get_luaentity():get_armor_groups().immortal or 0

					if minetest.is_player(tgt) or immortal == 0 then
						tgt:punch(ctx.caster, 1, {
							full_punch_interval = 1;
							damage_groups = { fleshy = force / 10 };
						})
					end
					sparktrail(nil,tgt,sorcery.lib.color(101,226,255))
................................................................................
							end;
							[{whence=0, secs=1}] = function(s)
								s.affect {
									duration = power * 0.50;
									raise = 0.5;
									-- fall = (power * 0.25) * 0.3;
									impacts = {
										gravity = 0.1;
									};
								}
							end;
						};
						intervals = {
							{period = 0.2, after = {whence=0, secs=2}; fn = function(c)
							-- return gravity to normal once they touch down
................................................................................
								for _,sub in pairs(s.subjects) do
									sub.player:add_velocity{y=-power*2;x=0,z=0}
								end
							end or nil;
						};
						sounds = {
							[0.3] = {
								sound = 'sorcery_hurl';
								where = 'subjects';
								ephemeral = true;
							};
							[1] = (ctx.amulet.frame == 'cobalt') and {
								sound = 'sorcery_hurl';
								where = 'subjects';
								ephemeral = true;
................................................................................
				desc = 'Unleash a tidal wave of force in every direction, blasting friends and foes alike away from you with enough violence to sprain and fracture bone';
			};
		};
	};
	obliterate = {
		name = 'Obliterate';
		tone = {255,0,10};
		minpower = 5;
		rarity = 30;
		amulets = {
			amethyst = {
				name = 'Sapping';
				desc = 'Punch a hole in enemy fortifications big enough to slip through but small enough to avoid immediate attention';
			};
			ruby = {
				name = 'Shattering';
................................................................................
				};
			};
		};
	};
	excavate = {
		name = 'Excavate';
		tone = {0,68,235};
		minpower = 3;
		rarity = 17;
		amulets = {
			luxite = {
				name = 'Stonestride';
				desc = 'Rock walls will open up before you when you brandish this amulet before them, closing up again behind you without leaving a trace of your passage';
			};
			sapphire = {
				name = 'Tunnelling';
................................................................................
				desc = 'Cut a wide shaft up into the ceiling of a cavern';
			};
		};
	};
	genesis = {
		name = 'Genesis';
		tone = {235,0,175};
		minpower = 5;
		rarity = 23;
		amulets = {
			amethyst = {
				name = 'Shelter';
				desc = 'Pour the power of this amulet into the soil or sand and out will grow a warm and well-lit place of shelter, no matter how far you may be from civilization.';
				cast = function(ctx)
					local ctr = ctx.caster:get_pos()
					local dim = { rmax = 2 + 6 * (ctx.stats.power*0.1) }
................................................................................
				};
			};
		};
	};
	dominate = {
		name = 'Dominate';
		tone = {235,0,228};
		minpower = 4;
		rarity = 13;
		amulets = {
			amethyst = {
				name = 'Suffocation';
				desc = 'Wrap this spell tightly around your victim\'s throat, cutting off their oxygen until you release them.';
			};
			emerald = {
				name = 'Caging';

-- a rune is an abstract object created by a runeforge, which can be
-- applied to an amulet in order to imbue that amulet with unique
-- and fearsome powers. the specific spell depends on the stone the
-- rune is applied to, and not all runes can necessarily be applied
-- to all stones.

local L = sorcery.lib
local sparkle_region = function(s)
	s.spell.visual_subjects {
		amount = s.amt, time = s.time, -- attached = s;
		minpos = s.minpos;
		maxpos = s.maxpos;
		minvel = { x = -0.4, y = -0.2, z = -0.4 };
		maxvel = { x =  0.4, y =  0.2, z =  0.4 };
................................................................................
	sorcery.spell.disjoin{target=target}
end

return {
	translocate = {
		name = 'Translocate';
		tone = {0,235,233};
		minpower = 2;
		rarity = 8;
		amulets = {
			amethyst = {
				name = 'Joining';
				desc = 'Give this amulet to another and with a snap of their fingers they can arrive safely at your side from anywhere in the world — though returning whence they came may be a more difficult matter';
				apply = function(ctx)
					local maker = ctx.user:get_player_name()
					ctx.meta:set_string('rune_join_target',maker)
................................................................................
			};
		};
	};
	disjoin = {
		name = 'Disjoin';
		tone = {159,235,0};
		minpower = 4;
		rarity = 10;
		amulets = {
			sapphire = {
				name = 'Unsealing';
				desc = 'Wielding this amulet, a touch of your hand will unravel even the mightiest protective magics, leaving doors unsealed and walls free to tear down';
				sound = 'sorcery_disjoin';
				cast = function(ctx)
					if ctx.target.type ~= 'node' then return false end
					local r = 2 + math.floor(ctx.stats.power / 2)
					local cast = false
					for x = -r,r do
					for y = -r,r do
					for z = -r,r do
................................................................................
					end
					return cast
				end;
			};
			amethyst = {
				name = 'Purging';
				desc = 'Free yourself from the grip of any malicious spellwork with a snap of your fingers — interrupting all of your own active spells in the process, including impending translocations';
				sound = 'sorcery_disjoin';
				cast = function(ctx) purge(ctx.caster) end;
			};
			emerald = {
				name = 'Disjunction Field';
				desc = 'Render an area totally opaque to spellwork for a period of time, disrupting any existing spells and preventing further spellcasting therein';
				sound = 'sorcery_disjoin';
			};
			ruby = {
				name = 'Disjunction';
				desc = 'Wield this amulet against a spellcaster to disrupt and abort all their spells in progress, perhaps to trap a foe intent on translocating away, or unleash its force upon the victim of a malign hex to free them from its clutches';
				mingrade = 3;
				sound = 'sorcery_disjoin';
				cast = function(ctx)
					if ctx.target.type == 'object'
						then purge(ctx.target.ref)
						else return false
					end
				end;
				frame = {
................................................................................
						desc = 'Not only will your victim\'s spells be nullified, but all enchanted objects they carry will be stripped of their power — or possibly even destroyed outright';
					};
				};
			};
			luxite = {
				name = 'Disjunctive Aura';
				desc = 'For a time, all magic undertaken in your vicinity will fail totally — including your own';
				sound = 'sorcery_disjoin';
				cast = function(ctx)
					local h = ctx.heading.eyeheight*1.1
					sorcery.spell.cast {
						name = 'sorcery:disjunctive-aura';
						caster = ctx.caster, attach = 'caster';
						subjects = {{player=ctx.caster}};
						disjunction = true, range = 4 + ctx.stats.power;
................................................................................
									minpos = { x = 0-range, y = -0.5, z = 0-range };
									maxpos = { x =   range, y = h,    z =   range };
									img = sorcery.lib.image('sorcery_flicker.png'):glow(sorcery.lib.color(120,255,30));
								}
							end;
						};
						sounds = {
							-- [0.00] = {sound='sorcery_disjoin',   where='caster'};
							[{whence=0,secs=0.8}] = {
								sound='sorcery_disjoin_bg', where='subjects';
								gain=0.5, stop = {whence=1,secs=-1.5}
							};
							[1.00] = {sound='sorcery_powerdown', where='caster'};
						};
					}
				end
			};
			diamond = {
				name = 'Mundanity';
				desc = 'Strip away the effects of all active potions and spells in your immediate vicinity, leaving adversaries without their magicks to enhance and protect them, and allies free of any curses they may be hobbled by -- and, of course, vice versa';
				sound = 'sorcery_disjoin';
				cast = function(ctx)
					local where = ctx.caster:get_pos()
					local what = minetest.get_objects_inside_radius(where, 3 + (2*ctx.stats.power))
					local who = {}
					local pfac = math.min(1, ctx.stats.power/8)
					for _, w in pairs(what) do
						if w:is_player() and w ~= ctx.caster then
................................................................................
						};
					}
				end;
				frame = {
					iridium = {
						name = 'Spellshatter';
						desc = 'Blast out a tidal wave of anti-magic that will nullify active spells, but also disenchant or destroy all magical items in range of its violently mundane grip';
						sound = 'sorcery_disjoin';
						cast = function(ctx)
							local where = ctx.caster:get_pos()
							local radius = 3 + (2*ctx.stats.power)
							local what = minetest.get_objects_inside_radius(where, radius)
							local who = {}
							local pfac = math.min(1, ctx.stats.power/8)
							for _, w in pairs(what) do
................................................................................
											minsize = 0.7, maxsize = 2;
											animation = {
												type = 'vertical_frames', length = (21/6) + 0.1;
												aspect_w = 16, aspect_h = 16;
											}
										}
									end;
								};
								sounds = {
									[{whence=0,secs=0.8}] = {
										sound='sorcery_disjoin_bg', where=where;
										gain=0.5, stop = {whence=1,secs=-0.6}
									};
								};
								intervals = {
									{period = 0.1, after = 0.15, fn = function(c)
										for i = 1,80 do
											local life = 0.2 + math.random() * 2
											local dir = vector.new(math.random()-0.5,0,math.random()-0.5):normalize()
											local pos = epicenter + (dir * (math.random()*radius))
................................................................................
												}
											}
										end
										if next(wreck) then
											local k,p = sorcery.lib.tbl.pick(wreck)

											minetest.add_particle {
												texture = L.image('sorcery_sparking.png'):glow(L.color(0,255,0)):render();
												pos = vector.offset(p,math.random(),math.random(),math.random());
												expirationtime = 1;
												size = 5 + math.random() * 4;
												glow = 14;
												animation = {
													type = 'vertical_frames', length = 0.3;
													aspect_w = 64, aspect_h = 64;
												}
											}
											minetest.add_particle {
												texture = L.image('sorcery_crackle.png'):glow(L.color(0,255,0)):render();
												pos = vector.offset(p,math.random(),math.random(),math.random());
												expirationtime = 1;
												size = 4 + math.random() * 6;
												glow = 14;
												animation = {
													type = 'vertical_frames', length = 1.1;
													aspect_w = 64, aspect_h = 64;
												}
											}
											if math.random(1,7) == 1 then
												minetest.sound_play('sorcery_' .. (math.random(1,2)==1 and 'rip' or 'crunch'), {
													pos = p;
													gain = math.random(5,13)*0.1;
												}, true)
												minetest.after(0.2, function() minetest.remove_node(p) end)
												sorcery.vfx.show {
													amount = 120, time = 0.3;
													kind = 'flicker', color = L.color(80,255,10);--(255,12,0);
													pos = p, radius = 0.4;
													velrange = 1, accrange = vector.new(0.0,0.2,0.0);
													minsize = 5, maxsize = 20;
													life = 0.6, varylife = 0.1;
												}
												sorcery.vfx.show {
													amount = 80, time = 0.2;
													minsize = 0.1, maxsize = 0.8;
													pos = p, radius = 0.6;
													node = minetest.get_node(p);
													vel = vector.new(0,7,0);
													velrange = vector.new(2, 4, 2);
													acc = vector.new(0,-9,0);
													life = 3, varylife = 0.4;
												}
												-- minetest.add_particlespawner {
												-- 	amount = 60, time = 0.2;
												-- 	texture = L.image('sorcery_flicker.png'):glow():render();
												-- 	minpos = vector.offset(p, -0.5, -0.5, -0.5);
												-- 	maxpos = vector.offset(p,  0.5,  0.5,  0.5);
												-- 	minacc = vector.new(0.0, -0.2, 0.0);
												-- 	maxacc = vector.new(0.0,  0.2, 0.0);
												-- 	minvel = vector.new(-1,-1,-1);
												-- 	maxvel = vector.new(1,1,1);
												-- 	minsize = 0.5, maxsize = 4;
												-- 	minexptime = 0.6, maxexptime = 0.7;
												-- 	animation = {
												-- 		type = 'vertical_frames';
												-- 		aspect_w = 16, aspect_h = 16;
												-- 		length = 0.8;
												-- 	}
												-- }
												table.remove(wreck,k)
											end
										end
									end};
								};
							}
						end;
					};
				};
................................................................................
			};
		}
	};
	repulse = {
		name = 'Repulse';
		tone = {0,180,235};
		minpower = 1;
		rarity = 7;
		amulets = {
			amethyst = {
				name = 'Hurling';
				desc = 'Wielding this amulet, a mere flick of your fingers will lift any target of your choice bodily into the air and press upon them with tremendous repulsive force, throwing them like a hapless ragdoll out of your path';
				cast = function(ctx)
					if not (ctx.target and ctx.target.type == 'object') then return false end
					local tgt = ctx.target.ref
					local line = vector.subtract(ctx.caster:get_pos(), tgt:get_pos())
					-- direction vector from target to caster
					local dir,mag = sorcery.lib.math.vsep(line)
					if mag > 6 then return false end -- no cheating!
					local force = 20 + (ctx.stats.power * 2.5)
					minetest.sound_play('sorcery_slide',{pos=tgt:get_pos()},true)
					local immortal = 0
					-- if tgt and tgt.get_armor_groups then
						immortal = tgt:get_armor_groups().immortal or 0
					-- end
					if minetest.is_player(tgt) or immortal == 0 then
						tgt:punch(ctx.caster, 1, {
							full_punch_interval = 1;
							damage_groups = { fleshy = force / 10 };
						})
					end
					sparktrail(nil,tgt,sorcery.lib.color(101,226,255))
................................................................................
							end;
							[{whence=0, secs=1}] = function(s)
								s.affect {
									duration = power * 0.50;
									raise = 0.5;
									-- fall = (power * 0.25) * 0.3;
									impacts = {
										gravity = 0.2;
									};
								}
							end;
						};
						intervals = {
							{period = 0.2, after = {whence=0, secs=2}; fn = function(c)
							-- return gravity to normal once they touch down
................................................................................
								for _,sub in pairs(s.subjects) do
									sub.player:add_velocity{y=-power*2;x=0,z=0}
								end
							end or nil;
						};
						sounds = {
							[0.3] = {
								sound = 'sorcery_slide';
								where = 'subjects';
								ephemeral = true;
							};
							[1] = (ctx.amulet.frame == 'cobalt') and {
								sound = 'sorcery_hurl';
								where = 'subjects';
								ephemeral = true;
................................................................................
				desc = 'Unleash a tidal wave of force in every direction, blasting friends and foes alike away from you with enough violence to sprain and fracture bone';
			};
		};
	};
	obliterate = {
		name = 'Obliterate';
		tone = {255,0,10};
		minpower = 4;
		rarity = 10;
		amulets = {
			amethyst = {
				name = 'Sapping';
				desc = 'Punch a hole in enemy fortifications big enough to slip through but small enough to avoid immediate attention';
			};
			ruby = {
				name = 'Shattering';
................................................................................
				};
			};
		};
	};
	excavate = {
		name = 'Excavate';
		tone = {0,68,235};
		minpower = 2;
		rarity = 9;
		amulets = {
			luxite = {
				name = 'Stonestride';
				desc = 'Rock walls will open up before you when you brandish this amulet before them, closing up again behind you without leaving a trace of your passage';
			};
			sapphire = {
				name = 'Tunnelling';
................................................................................
				desc = 'Cut a wide shaft up into the ceiling of a cavern';
			};
		};
	};
	genesis = {
		name = 'Genesis';
		tone = {235,0,175};
		minpower = 3;
		rarity = 12;
		amulets = {
			amethyst = {
				name = 'Shelter';
				desc = 'Pour the power of this amulet into the soil or sand and out will grow a warm and well-lit place of shelter, no matter how far you may be from civilization.';
				cast = function(ctx)
					local ctr = ctx.caster:get_pos()
					local dim = { rmax = 2 + 6 * (ctx.stats.power*0.1) }
................................................................................
				};
			};
		};
	};
	dominate = {
		name = 'Dominate';
		tone = {235,0,228};
		minpower = 3;
		rarity = 12;
		amulets = {
			amethyst = {
				name = 'Suffocation';
				desc = 'Wrap this spell tightly around your victim\'s throat, cutting off their oxygen until you release them.';
			};
			emerald = {
				name = 'Caging';

					pos   = user:get_pos();
					yaw   = user:get_look_dir();
					pitch = user:get_look_vertical();
					angle = user:get_look_horizontal();
					eyeheight = user:get_properties().eye_height;
				};

				sound = "xdecor_enchanting"; --FIXME make own sounds
				sparkle = true;
			}
			local res = sp.cast(ctx)

			if res == nil or res == true then
				minetest.sound_play(ctx.sound, { 
					pos = user:get_pos();
					gain = 1;
				})
			end
			if ctx.sparkle then
				sorcery.vfx.cast_sparkle(user, ctx.color, stats.power,0.5)
			end
			local infinirune = minetest.check_player_privs(user, 'sorcery:infinirune')
			if res == nil then
				if not infinirune then sorcery.amulet.setrune(usedamulet) end
			end

			if stack:get_count() == 1 then
................................................................................
				recipe = {
					{amuletname};
					{disc};
					-- {'',  frag,''};
					-- {frag,amuletname,frag};
					-- {'',  frag,''};
				};









			}
		end)
	end
	minetest.register_craft {
		type = 'shapeless';
		recipe = (minetest.get_modpath('xdecor') and {
			'xdecor:hammer', itemname;

					pos   = user:get_pos();
					yaw   = user:get_look_dir();
					pitch = user:get_look_vertical();
					angle = user:get_look_horizontal();
					eyeheight = user:get_properties().eye_height;
				};

				sound = sp.sound or "xdecor_enchanting"; --FIXME make own sounds
				sparkle = true;
			}
			local res = sp.cast(ctx)

			if res == nil or res == true and ctx.sound then
				minetest.sound_play(ctx.sound, { 
					pos = user:get_pos();
					gain = 1;
				})
			end
			if ctx.sparkle then
				sorcery.vfx.cast_sparkle(user, ctx.color, stats.power,0.2)
			end
			local infinirune = minetest.check_player_privs(user, 'sorcery:infinirune')
			if res == nil then
				if not infinirune then sorcery.amulet.setrune(usedamulet) end
			end

			if stack:get_count() == 1 then
................................................................................
				recipe = {
					{amuletname};
					{disc};
					-- {'',  frag,''};
					-- {frag,amuletname,frag};
					-- {'',  frag,''};
				};
			}
			minetest.register_craft {
				output = amuletname;
				type = 'shapeless';
				recipe = { framedid, 'xdecor:hammer'; };
				replacements = {
					{'xdecor:hammer', 'xdecor:hammer'};
					{framedid, disc};
				};
			}
		end)
	end
	minetest.register_craft {
		type = 'shapeless';
		recipe = (minetest.get_modpath('xdecor') and {
			'xdecor:hammer', itemname;

-- to generate runes and that wears down over time, to make amulets more
-- expensive than they currently are? the existing system is neat but
-- i think amulets are a little overpowered for something that just
-- passively consumes ley-current
--  -- are phials & rune-wrenches enough for this now?

local constants = {
	rune_mine_interval = 240;
	-- how often a powered forge rolls for new runes

	rune_cache_max = 6;
	-- how many runes a runeforge can hold at a time
	
	rune_grades = {'Fragile', 'Weak', 'Ordinary', 'Pristine', 'Sublime'};
	-- how many grades of rune quality/power there are
................................................................................
	};
}
local calc_phial_props = function(phial) --> mine interval: float, power factor: float
	local m = phial:get_meta()
	local g = phial:get_definition()._proto.data.grade
	local i = constants.rune_mine_interval 
	local fac = (g-1) / 5
	fac = fac + 0.2 * m:get_int('speed')
	return math.max(3,i - ((i*0.5) * fac)), 0.5 * fac
end
sorcery.register.runes.foreach('sorcery:generate',{},function(name,rune)
	local id = 'sorcery:rune_' .. name
	rune.image = rune.image or string.format('sorcery_rune_%s.png',name)
	rune.item = id
	local c = sorcery.lib.color(rune.tone)
................................................................................
	local proto = stack:get_definition()._sorcery.amulet
	if not m:contains('amulet_rune') then return nil end
	local rune = m:get_string('amulet_rune')
	local rg = m:get_int('amulet_rune_grade')
	local rd = sorcery.data.runes[rune]
	local spell = rd.amulets[proto.base]
	if not spell then return nil end
	local title,desc,cast,apply,remove,mingrade = spell.name, spell.desc, spell.cast, spell.apply, spell.remove, spell.mingrade -- FIXME in serious need of refactoring
	local base_spell = true

	if proto.frame and spell.frame and spell.frame[proto.frame] then
		local sp = spell.frame[proto.frame]
		if not sp.mingrade or rg >= sp.mingrade then
			title = sp.name or title
			desc = sp.desc or desc
			cast = sp.cast or cast
			apply = sp.apply or apply
			remove = sp.remove or remove
			mingrade = sp.mingrade or mingrade

			base_spell = false
		end
	end
	

	return {
		rune = rune, grade = rg;
		spell = spell, mingrade = mingrade;
		name = title, desc = desc;
		cast = cast, apply = apply, remove = remove;
		frame = proto.frame;
		framestats = proto.frame and sorcery.data.metals[proto.frame].amulet;
		tone = sorcery.lib.color(rd.tone);
		base_spell = base_spell;
	}
end
................................................................................
	if time and has_phial() and pow_min and not probe.disjunction then -- roll for runes
		local phial = i:get_stack('phial',1)
		local int, powerfac = calc_phial_props(phial)
		local pf = phial:get_meta():get_int('force')
		local rolls = math.floor(time/int)
		local newrunes = {}
		for _=1,rolls do

			local choices = {}
			for name,rune in pairs(sorcery.data.runes) do
				-- print('considering',name)
				-- print('-- power',rune.minpower,(rune.minpower*powerfac)*time,'//',l.self.powerdraw,l.self.powerdraw/time,'free',l.freepower,'max',l.maxpower)
				if (rune.minpower*powerfac)*time <= l.self.powerdraw and math.random(rune.rarity - pf) == 1 then





					choices[#choices + 1] = rune
				end
			end

			if #choices > 0 then
				-- if multiple runes were rolled up, be nice to the player
				-- and pick the rarest one to give them
				local rare, choice = 0
				for i,c in pairs(choices) do
					if c.rarity > rare then
						rare = c.rarity
						choice = c



					end
				end
				newrunes[#newrunes + 1] = ItemStack(choice.item)
			end
			-- print('rune choices:',dump(choices))
			-- print('me',dump(l.self))
		end

		for _,r in pairs(newrunes) do
			if i:room_for_item('cache',r) and has_phial() then
................................................................................
		local i = m:get_inventory()
		i:set_size('cache',constants.rune_cache_max)
		i:set_size('wrench',1) i:set_size('phial',1) i:set_size('refuse',1)
		i:set_size('amulet',1) i:set_size('active',1)
		m:set_string('infotext','Rune Forge')
		runeforge_update(pos)
	end;
	after_dig_node = sorcery.lib.node.purge_only {'amulet','wrench'};
	on_timer = runeforge_update;
	on_metadata_inventory_move = function(pos, fl,fi, tl,ti, count, user)
		local inv = minetest.get_meta(pos):get_inventory()
		local wrench if not inv:is_empty('wrench') then
			wrench = inv:get_stack('wrench',1):get_definition()._proto
		end
		local wwear = function(cap)

-- to generate runes and that wears down over time, to make amulets more
-- expensive than they currently are? the existing system is neat but
-- i think amulets are a little overpowered for something that just
-- passively consumes ley-current
--  -- are phials & rune-wrenches enough for this now?

local constants = {
	rune_mine_interval = 180;
	-- how often a powered forge rolls for new runes

	rune_cache_max = 6;
	-- how many runes a runeforge can hold at a time
	
	rune_grades = {'Fragile', 'Weak', 'Ordinary', 'Pristine', 'Sublime'};
	-- how many grades of rune quality/power there are
................................................................................
	};
}
local calc_phial_props = function(phial) --> mine interval: float, power factor: float
	local m = phial:get_meta()
	local g = phial:get_definition()._proto.data.grade
	local i = constants.rune_mine_interval 
	local fac = (g-1) / 5
	fac = fac + 0.1 * m:get_int('speed')
	return math.max(3,i - ((i*0.5) * fac)), 0.5 * fac
end
sorcery.register.runes.foreach('sorcery:generate',{},function(name,rune)
	local id = 'sorcery:rune_' .. name
	rune.image = rune.image or string.format('sorcery_rune_%s.png',name)
	rune.item = id
	local c = sorcery.lib.color(rune.tone)
................................................................................
	local proto = stack:get_definition()._sorcery.amulet
	if not m:contains('amulet_rune') then return nil end
	local rune = m:get_string('amulet_rune')
	local rg = m:get_int('amulet_rune_grade')
	local rd = sorcery.data.runes[rune]
	local spell = rd.amulets[proto.base]
	if not spell then return nil end
	local title,desc,cast,apply,remove,mingrade,sound = spell.name, spell.desc, spell.cast, spell.apply, spell.remove, spell.mingrade,spell.sound -- FIXME in serious need of refactoring
	local base_spell = true

	if proto.frame and spell.frame and spell.frame[proto.frame] then
		local sp = spell.frame[proto.frame]
		if not sp.mingrade or rg >= sp.mingrade then
			title = sp.name or title
			desc = sp.desc or desc
			cast = sp.cast or cast
			apply = sp.apply or apply
			remove = sp.remove or remove
			mingrade = sp.mingrade or mingrade
			sound = sp.sound or sound
			base_spell = false
		end
	end
	
	-- PLEASE, GOD, REFACTOR ME
	return {
		rune = rune, grade = rg;
		spell = spell, mingrade = mingrade;
		name = title, desc = desc, sound = sound;
		cast = cast, apply = apply, remove = remove;
		frame = proto.frame;
		framestats = proto.frame and sorcery.data.metals[proto.frame].amulet;
		tone = sorcery.lib.color(rd.tone);
		base_spell = base_spell;
	}
end
................................................................................
	if time and has_phial() and pow_min and not probe.disjunction then -- roll for runes
		local phial = i:get_stack('phial',1)
		local int, powerfac = calc_phial_props(phial)
		local pf = phial:get_meta():get_int('force')
		local rolls = math.floor(time/int)
		local newrunes = {}
		for _=1,rolls do
			print('--- rune roll',_,'pf',pf)
			local choices = {}
			for name,rune in pairs(sorcery.data.runes) do


				local powreq = (rune.minpower*powerfac)*time 
				print('- rune', name)
				print('powreq',powreq)
				print('power draw',l.self.powerdraw)
				if powreq <= l.self.powerdraw then
					print(' ! sufficient power for rune')
					choices[#choices + 1] = rune
				end
			end
			for k,v in pairs(choices) do print(' * choice',k,v.item) end
			if #choices > 0 then

				for try = 1,#choices do
					print(' -- try',try)
					local _, choice = sorcery.lib.tbl.pick(choices)
					local adjrare = math.max(2, choice.rarity - pf)
					print(choice.item,'rarity',choice.rarity, 'adjusted', adjrare)
					if math.random(adjrare) == 1 then
						print(' ! picking ', choice.item)
						newrunes[#newrunes + 1] = ItemStack(choice.item)
						break
					end
				end

			end
			-- print('rune choices:',dump(choices))
			-- print('me',dump(l.self))
		end

		for _,r in pairs(newrunes) do
			if i:room_for_item('cache',r) and has_phial() then
................................................................................
		local i = m:get_inventory()
		i:set_size('cache',constants.rune_cache_max)
		i:set_size('wrench',1) i:set_size('phial',1) i:set_size('refuse',1)
		i:set_size('amulet',1) i:set_size('active',1)
		m:set_string('infotext','Rune Forge')
		runeforge_update(pos)
	end;
	after_dig_node = sorcery.lib.node.purge_only {'amulet','wrench','refuse','phial'};
	on_timer = runeforge_update;
	on_metadata_inventory_move = function(pos, fl,fi, tl,ti, count, user)
		local inv = minetest.get_meta(pos):get_inventory()
		local wrench if not inv:is_empty('wrench') then
			wrench = inv:get_stack('wrench',1):get_definition()._proto
		end
		local wwear = function(cap)

sorcery.vfx = {}
local L = sorcery.lib























































































































sorcery.vfx.glowspark = function(color)
	local spark = L.image('sorcery_spark.png')
	return spark:blit(spark:multiply(color))
end

sorcery.vfx.cast_sparkle = function(caster,color,strength,duration,pos)
	local ofs = pos
		and function(x) return vector.add(pos,x) end
		or  function(x) return x end
	local height = caster:get_properties().eye_height




















	minetest.add_particlespawner {
		amount = 70 * strength;
		time = duration or 1.5;
		attached = caster;
		-- texture = L.image('sorcery_spark.png'):multiply(color):render();
		texture = sorcery.vfx.glowspark(color):render();
		minpos = ofs({ x =  0.0, z =  0.6, y =  height*0.7});
		maxpos = ofs({ x =  0.4, z =  0.2, y =  height*1.1});
		minvel = { x = -0.5, z = -0.5, y = -0.5};
		maxvel = { x =  0.5, z =  0.5, y =  0.5};
		minacc = { x =  0.0, z =  0.0, y =  0.5};
		maxacc = { x =  0.0, z =  0.0, y =  0.5};
		minsize = 0.4, maxsize = 0.8;
		minexptime = 1, maxexptime = 1;
		glow = 14;
		animation = {
			type = 'vertical_frames';
			aspect_w = 16;
			aspect_h = 16;
			length = 1.1;
		};
	}

end

sorcery.vfx.body_sparkle = function(body,color,str,pos)
	local tex = L.image('sorcery_spark.png')
	local pi = tex:blit(tex:multiply(color)):render()
	local ofs = pos
		and function(x) return vector.add(pos,x) end

sorcery.vfx = {}
local L = sorcery.lib

sorcery.vfx.particle = {
	flicker = { fw = 64 };
	crackle = { fw = 64 };
	sparking = { fw = 16 };
	spark = { fw = 16 };
	sputter = { fw = 16 };
	glitter = { fw = 16 };
	poof = { fw = 16 };
	fog = { fw = 16};
}

sorcery.vfx.show = function(def)
	local sp = {}
	local p
	if def.kind then
		p = sorcery.vfx.particle[def.kind]
		local img = L.image(p.img or string.format('sorcery_%s.png', def.kind))
		if def.color then img = img:glow(def.color) end
		if def.warp then img = def:warp(img) end
		sp.texture = img:render()
	else
		sp.texture = def.texture
	end

	sp.collisiondetection = def.collisiondetection
	sp.collision_removal  = def.collision_removal
	sp.object_collision = def.object_collision

	local function q(bp, rp, ao, so)
		ao = ao or bp
		so = so or bp
		local min, max

		if def[bp] or def[rp] then
			local b = def[bp] or vector.new(0,0,0)
			if def[rp] then
				local r
				if type(def[rp]) == 'number' then
					r = vector.new(def[rp],def[rp],def[rp])
				else r = def[rp] end
				min = vector.subtract(b, r)
				max = vector.add     (b, r)
			else
				min, max = b,b
			end
		else
			local dflt = vector.new(0,0,0)
			min, max = def['min'..bp] or dflt, def['max'..bp] or dflt
		end

		if def.amount and def.amount > 1 then
			sp['min'..ao], sp['max'..ao] = min, max
		else
			if vector.equals(min,max) then sp[so] = min else
				local d = vector.subtract(max, min)
				sp[so]  = vector.add(min, vector.multiply(d, math.random()))
			end
		end
	end
	q('pos','radius')
	q('vel','velrange',   'vel', 'velocity')
	q('acc','accrange',   'acc', 'acceleration')
	local vary = def.varysize or 0
	if def.amount and def.amount > 1 then
		sp.amount = def.amount
		sp.time = def.time or def.life or 1
		def.life = def.life or sp.time

		sp.minsize = def.minsize or ((def.size or 1) - vary)
		sp.maxsize = def.maxsize or ((def.size or 1) + vary)
		sp.attached = def.attached
	else
		if def.minsize and def.maxsize then
			sp.size = def.minsize + ((def.maxsize - def.minsize) * math.random())
		elseif vary > 0 then
			sp.size = ((def.size or 1) - vary) + (vary*2*math.random())
		else sp.size = def.size end
		if def.attached then
			sp.pos = vector.add(
				vector.rotate(sp.pos,
					{x = 0, y = def.attached:get_yaw() or def.attached:get_look_horizontal(), z = 0}
				),
				def.attached:get_pos()
			)

			sp.velocity = vector.add(sp.velocity, def.attached:get_velocity())
		end
	end
	sp.node = def.node
	sp.playername = def.playername
	sp.vertical = def.vertical
	sp.glow = def.glow
	if def.life then
		if sp.amount then
			if def.varylife then
				sp.minexptime = def.life - def.varylife
				sp.maxexptime = def.life + def.varylife
			else
				sp.minexptime, sp.maxexptime = def.life, def.life
			end
		else
			sp.expirationtime = def.life
		end
	end
	if p and p.fw then
		sp.animation = {
			type = 'vertical_frames';
			aspect_w = p.fw, aspect_h = p.fh or p.fw;
			length = (sp.maxexptime or sp.life or 1) + 0.1;
		}
	end
	if sp.amount then
		minetest.add_particlespawner(sp)
	else
		minetest.add_particle(sp)
	end
end

sorcery.vfx.glowspark = function(color)
	local spark = L.image('sorcery_spark.png')
	return spark:blit(spark:multiply(color))
end

sorcery.vfx.cast_sparkle = function(caster,color,strength,duration,pos)
	local ofs = pos
		and function(x) return vector.add(pos,x) end
		or  function(x) return x end
	local height = caster:get_properties().eye_height
	sorcery.vfx.show {
		amount = 4 * (0.5+strength*0.5), time = duration or 1.5;
		kind = 'spark', color = color, glow = 14, life = 0.5;
		-- minpos = ofs({ x =  0.0, z =  0.6, y =  height - 0.7});
		-- maxpos = ofs({ x =  0.4, z =  0.2, y =  height - 0.3});
		pos = ofs(vector.new(0.2, height - 0.5, 0.4)), radius = 0.2;
		vel = vector.new(0,0,0.8);
		velrange = 0.7, acc = vector.new(0,0.5,0);
		minsize = 5, maxsize = 10;
		attached = caster;
	}
	sorcery.vfx.show {
		amount = 140 * strength, time = 0.3 + (duration or 1.5);
		kind = 'sputter', color = color, glow = 14, life = 3;
		pos = ofs(vector.new(0.2, height - 0.5, 0.5)), radius = 0.3;
		vel = vector.new(0,0,1.2);
		velrange = 0.4, acc = vector.new(0,0.5,-0.7);
		minsize = 0.05, maxsize = 0.4;
		attached = caster;
	}
	-- minetest.add_particlespawner {
	-- 	amount = 40 * strength;
	-- 	time = duration or 1.5;
	-- 	attached = caster;
	-- 	-- texture = L.image('sorcery_spark.png'):multiply(color):render();
	-- 	texture = sorcery.vfx.glowspark(color):render();


	-- 	minvel = { x = -0.5, z = -0.5, y = -0.5};
	-- 	maxvel = { x =  0.5, z =  0.5, y =  0.5};
	-- 	minacc = { x =  0.0, z =  0.0, y =  0.5};
	-- 	maxacc = { x =  0.0, z =  0.0, y =  0.5};
	-- 	minsize = 0.2, maxsize = 1.5;
	-- 	minexptime = 1, maxexptime = 1;
	-- 	glow = 14;
	-- 	animation = {
	-- 		type = 'vertical_frames';
	-- 		aspect_w = 16;
	-- 		aspect_h = 16;
	-- 		length = 1.1;
	-- 	};

	-- }
end

sorcery.vfx.body_sparkle = function(body,color,str,pos)
	local tex = L.image('sorcery_spark.png')
	local pi = tex:blit(tex:multiply(color)):render()
	local ofs = pos
		and function(x) return vector.add(pos,x) end