local vx,vy,vz = U.Rotate3D(0,0,1, xa, ya, za)
		
		if vy > 0.5 then 
			Prompt("6")
			return
		elseif vy < -0.5 then
			Prompt("1")
			return
		end
		
		vx,vy,vz = U.Rotate3D(0,1,0, xa, ya, za)
		
		if vy > 0.5 then 
			Prompt("5")
			return
		elseif vy < -0.5 then
			Prompt("2")
			return
		end
		
		vx,vy,vz = U.Rotate3D(1,0,0, xa, ya, za)	
		
		if vy > 0.5 then 
			Prompt("4")
			return
		elseif vy < -0.5 then
			Prompt("3")
			return
		end

local dice = {}

--[[ 
	dice.roll

	Rolls a pool of dice returning the sum and result of each die.
	e.g: dice.roll( { 6, 6 } ) would roll two six-sided dice.
]]

function dice.roll( pool )

	local total = 0
	local results = {}

	local x
	-- For each die in the pool..
	for _, v in pairs( pool ) do
		x = math.random( 1, v )		-- roll the die
		table.insert( results, x )	-- insert to results table
		total = total + x			-- add result to total
	end

	return total, results

end

--[[ 
	dice.minMax

	Returns the minimum, maximum, and average results of a die pool.
	e.g: dice.roll( { 10, 20 } ) would return min=2, max=30, avg=16
]]
function dice.minMax( pool )

	if #pool == 0 then return end

	-- The lowest face on each die is a 1, so the minimum is the number of dice
	local min = #pool

	-- Running totals
	local avg = 0
	local max = 0

	-- For each die..
	for _, v in pairs( pool ) do
		-- Increase the max by the highest face value 
		max = max + v
		-- Increase the average by the mean value of the die
		avg = avg + ( 1 + v ) / 2
	end

	return min, max, avg

end

--[[ 
	recurse
	!! Internal function, do not call !! 
	Use dice.stats to get frequency distributions.
]]
local function recurse( pool, iterator, total, results )

	-- if end of list reached
	if iterator > #pool then
		results[ total ] = ( results[ total ] or 0 ) + 1 -- add 1 to frequency of running total
	-- otherwise, 
	else
		-- for each face on current die, 
		for i = 1, pool[ iterator ] do
			-- recursively sum each face on each following die
			recurse( pool, iterator + 1, total + i, results )
		end

	end
end

--[[
	dice.stats

	Recursively analyses a pool of dice to find each possible result and the number of combinations
	that lead to each result.
	Passing a 'true' value to the second parameter normalises the distribution such that its area is unitary.
	Returns a table where the keys are the possible results and the values are the frequencies.
	
	e.g. dice.stats( { 6, 6 } [,false] ) would return:
	key 	value
	-------------
	2       1
	3       2
	4       3
	5       4
	6       5
	7       6
	8       5
	9       4
	10      3
	11      2
	12      1
]]

function dice.stats( pool, normalise )

	if #pool == 0 then return end
	local results = {}
	recurse( pool, 1, 0, results )

	if normalise then
		local combinations = 1
		for _, v in pairs( pool ) do
			combinations = combinations * v
		end

		for k, v in pairs( results  ) do
			results[ k ] = v / combinations
		end
	end

	return results

end

return dice

-- LUA Script - precede every function and global member with lowercase name of script + '_main'
local U = require "scriptbank\\utillib"
local Q = require "scriptbank\\quatlib"

local rad = math.rad
local deg = math.deg
rotating = 0
result = 0
function dice_throw_init( e )
	Include( "utillib.lua" )
end

function dice_throw_main( e )
	
	if startax == nil then 
		startax = g_Entity[e]['anglex']
		startay = g_Entity[e]['angley']
		startaz = g_Entity[e]['anglez']
		startx = g_Entity[e]['x']
		starty = g_Entity[e]['y']
		startz = g_Entity[e]['z']
	end 
	-- get new Euler angles
	if rotating == 0 then 
		CollisionOn(e)
		if g_Scancode == 18 then 
			result = 0
			rotating = 200
			SetRotation(e,startax,startay,startaz)
			SetPosition(e,startx,starty,startz)
			ResetPosition(e,startx,starty,startz)
			ResetRotation(e,startax,startay,startaz)
			rx = math.random(1200,1600)
			ry = math.random(200,600)
			rz = math.random(200,600)
		end
	elseif rotating > 0 then 
		CollisionOff(e)
		rotating = rotating-1 
		MoveUp(e,2)
		RotateX(e,rx)
		RotateY(e,ry)
		RotateZ(e,rz)
		CollisionOn(e)
	end 
	
	local xa, ya, za = rad( GetEntityAngleX( e ) ), rad(  GetEntityAngleY( e ) ), rad( GetEntityAngleZ( e ) )		
	local vx,vy,vz = U.Rotate3D(0,0,1, xa, ya, za)

	if rotating == 0 and g_Entity[e]['y'] <= starty+20 then 
		if vy > 0.5 then 
			PromptLocal(e, "4")
			result = 4
		elseif vy < -0.5 then
			PromptLocal(e, "3")
			result = 3
		end
	end 
		
		vx,vy,vz = U.Rotate3D(0,1,0, xa, ya, za)
		
		if rotating == 0 and g_Entity[e]['y'] <= starty+20 then  
			if vy > 0.5 then 
				PromptLocal(e, "6")
				result = 6 
			elseif vy < -0.5 then
				PromptLocal(e, "1")
				result = 1 
			end
		end 
		vx,vy,vz = U.Rotate3D(1,0,0, xa, ya, za)	
			
		if rotating == 0 and g_Entity[e]['y'] <= starty+20 then 
			if vy > 0.5 then 
				PromptLocal(e, "2")
				result = 2 
			elseif vy < -0.5 then
				PromptLocal(e, "5")
				result = 5 
			end
		end 
	if result > 0 then 
		Prompt("Result = "..result)
	end 
end